Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
16 messages Options
Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Ian Lynagh-2

Hi all,

The validate build is failing for me with the below. Does anyone know
what's up please?


Thanks
Ian


===--- building phase 0
make -r --no-print-directory -f ghc.mk phase=0 phase_0_builds
make[1]: Nothing to be done for `phase_0_builds'.
===--- building phase 1
make -r --no-print-directory -f ghc.mk phase=1 phase_1_builds
===--- building final phase
make -r --no-print-directory -f ghc.mk phase=final all
"inplace/bin/ghc-stage2" -hisuf hi -osuf  o -hcsuf hc -static  -H32m -O -Werror -Wall -H64m -O0    -package-name dph-prim-par-0.8.0.1 -hide-all-packages -i -ilibraries/dph/dph-prim-par/. -ilibraries/dph/dph-prim-par/dist-install/build -ilibraries/dph/dph-prim-par/dist-install/build/autogen -Ilibraries/dph/dph-prim-par/dist-install/build -Ilibraries/dph/dph-prim-par/dist-install/build/autogen -Ilibraries/dph/dph-prim-par/.    -optP-include -optPlibraries/dph/dph-prim-par/dist-install/build/autogen/cabal_macros.h -package base-4.7.0.0 -package dph-base-0.8.0.1 -package dph-prim-interface-0.8.0.1 -package dph-prim-seq-0.8.0.1 -package old-time-1.1.0.1 -package random-1.0.1.1 -package vector-0.9.1 -Odph -funbox-strict-fields -fcpr-off -Wall -XHaskell98 -XTypeFamilies -XGADTs -XRankNTypes -XBangPatterns -XMagicHash -XUnboxedTuples -XTypeOperators -XFlexibleInstances -XFlexibleContexts -O2 -O -dcore-lint -fno-warn-deprecated-flags  -no-user-package-db -rtsopts -Wwarn     -odir libraries/dph/dph-prim-par/dist-install/build -hidir libraries/dph/dph-prim-par/dist-install/build -stubdir libraries/dph/dph-prim-par/dist-install/build  -dynamic-too -c libraries/dph/dph-prim-par/./Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.hs -o libraries/dph/dph-prim-par/dist-install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.o -dyno libraries/dph/dph-prim-par/dist-install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.dyn_o
Var/Type length mismatch:
    []
    [s{tv a15I} [tv]]
ghc-stage2: panic! (the 'impossible' happened)
  (GHC version 7.7.20130530 for x86_64-unknown-linux):
        Iface Lint failure
    In interface for dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector
    Unfolding of dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$fDTVector_$cnewMD{v rS}
      <no location info>: Warning:
          In the expression: base:Control.Monad.liftM2{v rC} [gid]
                               @ (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                    ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
                               @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
                                    s3{tv a1Zk} [tv]
                                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                       a4{tv a1Zi} [tv]))
                               @ (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                       a4{tv a1Zi} [tv])
                                    s3{tv a1Zk} [tv])
                               @ (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv])
                               (base:GHC.ST.$fMonadST{v rA} [gid[DFunId]] @ s3{tv a1Zk} [tv])
                               (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz} [gid[DataConWrapper]]
                                  @ a4{tv a1Zi} [tv] @ s3{tv a1Zk} [tv])
                               ((dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v ry} [gid]
                                   @ s3{tv a1Zk} [tv] g{v a1Zl} [lid])
                                `cast` (Sym
                                          (base:GHC.ST.NTCo:ST{tc rx}[0]
                                             <s3{tv a1Zk} [tv]>
                                             <dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                                ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]>)
                                        :: base:GHC.ST.STRep{tc r1j3}
                                             s3{tv a1Zk} [tv]
                                             (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                                ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
                                             ~#
                                           base:GHC.ST.ST{tc rE}
                                             s3{tv a1Zk} [tv]
                                             (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                                ghc-prim:GHC.Types.Int{(w) tc 3J}
                                                s3{tv a1Zk} [tv])))
                               ((\ (s4{v a21s} [lid]
                                      :: ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv]) ->
                                   case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw} [gid]
                                          @ ghc-prim:GHC.Types.Int{(w) tc 3J}
                                          @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
                                             -> ghc-prim:GHC.Types.Int{(w) tc 3J})
                                          ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv} [gid]
                                          (ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]] 0)
                                          (case g{v a1Zl} [lid]
                                           {ghc-prim:GHC.Types.Int{(w) tc 3J}}
                                           of (wild{v a27g} [lid]
                                                 :: dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
                                           { dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} (dt{v a27R} [lid]
                                                                                                                                        :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
                                                                                                                                     (ds1{v a27S} [lid]
                                                                                                                                        :: [base:GHC.MVar.MVar{tc r1Q2}
                                                                                                                                              dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Req{tc r1Q1}])
                                                                                                                                     (ds2{v a27T} [lid]
                                                                                                                                        :: base:GHC.MVar.MVar{tc r1Q2}
                                                                                                                                             ghc-prim:GHC.Types.Bool{(w) tc 3c}) ->
                                           ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
                                             dt{v a27R} [lid]
                                           })
                                   {(# ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv],
                                       vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                         (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                            (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
                                         (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                            a4{tv a1Zi} [tv]) #)}
                                   of (wild{v a27V} [lid] :: ghc-prim:GHC.Types.Int{(w) tc 3J})
                                   { ghc-prim:GHC.Types.I#{(w) d 6c} (n#{v a280} [lid]
                                                                        :: ghc-prim:GHC.Prim.Int#{(w) tc 3G}) ->
                                   case ghc-prim:GHC.Prim.newArray#{(w) v 920} [gid[PrimOp]]
                                          @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                               a4{tv a1Zi} [tv])
                                          @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                               (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
                                          n#{v a280} [lid]
                                          (base:GHC.Err.error{(w) v 05} [gid]
                                             @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                  a4{tv a1Zi} [tv])
                                             (ghc-prim:GHC.CString.unpackCString#{v 0k} [gid]
                                                "MDist (Vector a) - uninitalised"#))
                                          (s4{v a21s} [lid]
                                           `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                     (Sym
                                                        (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
                                                           <s3{tv a1Zk} [tv]>))
                                                   :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                        s3{tv a1Zk} [tv]
                                                        ~#
                                                      ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                        (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                           (base:GHC.ST.ST{tc rE}
                                                              s3{tv a1Zk} [tv]))))
                                   {(# ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv],
                                       vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                         (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                            (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
                                         (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                            a4{tv a1Zi} [tv]) #)}
                                   of (ds1{v a282} [lid]
                                         :: (# ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                 (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                    (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv])),
                                               ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
                                                 (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                    (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
                                                 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                    a4{tv a1Zi} [tv]) #))
                                   { (# (ipv{v a284} [lid]
                                           :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                   (base:GHC.ST.ST{tc rE}
                                                      s3{tv a1Zk} [tv]))), (ipv1{v a285} [lid]
                                                                              :: ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
                                                                                   (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                      (base:GHC.ST.ST{tc rE}
                                                                                         s3{tv a1Zk} [tv]))
                                                                                   (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                      a4{tv a1Zi} [tv])) #) ->
                                   (# ipv{v a284} [lid]
                                      `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
                                                   <s3{tv a1Zk} [tv]>)
                                              :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                   (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                      (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
                                                   ~#
                                                 ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                   s3{tv a1Zk} [tv]),
                                      vector-0.9.1:Data.Vector.Mutable.MVector{v rr} [gid[DataCon]]
                                        @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                             (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
                                        @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                             a4{tv a1Zi} [tv])
                                        0
                                        n#{v a280} [lid]
                                        ipv1{v a285} [lid] #)
                                   }
                                   })
                                `cast` (Sym
                                          (base:GHC.ST.NTCo:ST{tc rx}[0]
                                             <s3{tv a1Zk} [tv]>
                                             (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                                (Sym
                                                   (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
                                                      <s3{tv a1Zk} [tv]>))
                                                <vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                   a4{tv a1Zi} [tv]>))
                                        :: base:GHC.ST.STRep{tc r1j3}
                                             s3{tv a1Zk} [tv]
                                             (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                                (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                   (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
                                                (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                   a4{tv a1Zi} [tv]))
                                             ~#
                                           base:GHC.ST.ST{tc rE}
                                             s3{tv a1Zk} [tv]
                                             (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                                s3{tv a1Zk} [tv]
                                                (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                   a4{tv a1Zi} [tv]))))
          Argument value doesn't match argument type:
          Fun type:
              (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]
               -> vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
                    s3{tv a1Zk} [tv]
                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                       a4{tv a1Zi} [tv])
               -> dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                       a4{tv a1Zi} [tv])
                    s3{tv a1Zk} [tv])
              -> base:GHC.ST.ST{tc rE}
                   s3{tv a1Zk} [tv]
                   (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                      ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
              -> base:GHC.ST.ST{tc rE}
                   s3{tv a1Zk} [tv]
                   (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
                      s3{tv a1Zk} [tv]
                      (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                         a4{tv a1Zi} [tv]))
              -> base:GHC.ST.ST{tc rE}
                   s3{tv a1Zk} [tv]
                   (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                      (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                         a4{tv a1Zi} [tv])
                      s3{tv a1Zk} [tv])
          Arg type:
              dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]
              -> vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
                   s3{tv a1Zk} [tv]
                   (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                      a4{tv a1Zi} [tv])
              -> dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                   (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                      a4{tv a1Zi} [tv])
          Arg:
              dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz} [gid[DataConWrapper]]
                @ a4{tv a1Zi} [tv] @ s3{tv a1Zk} [tv]
    dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$fDTVector_$cnewMD{v rS} = \ (@ a4{tv a1Zi} [tv])
                                                                                                           ($dUnbox{v a1Zj} [lid]
                                                                                                              :: vector-0.9.1:Data.Vector.Unboxed.Base.Unbox{tc rW}
                                                                                                                   a4{tv a1Zi} [tv])
                                                                                                           (@ s3{tv a1Zk} [tv])
                                                                                                           (g{v a1Zl} [lid]
                                                                                                              :: dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF}) ->
                                                                                                           base:Control.Monad.liftM2{v rC} [gid]
                                                                                                             @ (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                                                                                                  ghc-prim:GHC.Types.Int{(w) tc 3J}
                                                                                                                  s3{tv a1Zk} [tv])
                                                                                                             @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
                                                                                                                  s3{tv a1Zk} [tv]
                                                                                                                  (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                     a4{tv a1Zi} [tv]))
                                                                                                             @ (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                                                                                                  (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                     a4{tv a1Zi} [tv])
                                                                                                                  s3{tv a1Zk} [tv])
                                                                                                             @ (base:GHC.ST.ST{tc rE}
                                                                                                                  s3{tv a1Zk} [tv])
                                                                                                             (base:GHC.ST.$fMonadST{v rA} [gid[DFunId]]
                                                                                                                @ s3{tv a1Zk} [tv])
                                                                                                             (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz} [gid[DataConWrapper]]
                                                                                                                @ a4{tv a1Zi} [tv]
                                                                                                                @ s3{tv a1Zk} [tv])
                                                                                                             ((dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v ry} [gid]
                                                                                                                 @ s3{tv a1Zk} [tv]
                                                                                                                 g{v a1Zl} [lid])
                                                                                                              `cast` (Sym
                                                                                                                        (base:GHC.ST.NTCo:ST{tc rx}[0]
                                                                                                                           <s3{tv a1Zk} [tv]>
                                                                                                                           <dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                                                                                                              ghc-prim:GHC.Types.Int{(w) tc 3J}
                                                                                                                              s3{tv a1Zk} [tv]>)
                                                                                                                      :: base:GHC.ST.STRep{tc r1j3}
                                                                                                                           s3{tv a1Zk} [tv]
                                                                                                                           (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                                                                                                              ghc-prim:GHC.Types.Int{(w) tc 3J}
                                                                                                                              s3{tv a1Zk} [tv])
                                                                                                                           ~#
                                                                                                                         base:GHC.ST.ST{tc rE}
                                                                                                                           s3{tv a1Zk} [tv]
                                                                                                                           (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                                                                                                              ghc-prim:GHC.Types.Int{(w) tc 3J}
                                                                                                                              s3{tv a1Zk} [tv])))
                                                                                                             ((\ (s4{v a21s} [lid]
                                                                                                                    :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                         s3{tv a1Zk} [tv]) ->
                                                                                                                 case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw} [gid]
                                                                                                                        @ ghc-prim:GHC.Types.Int{(w) tc 3J}
                                                                                                                        @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
                                                                                                                           -> ghc-prim:GHC.Types.Int{(w) tc 3J})
                                                                                                                        ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv} [gid]
                                                                                                                        (ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
                                                                                                                           0)
                                                                                                                        (case g{v a1Zl} [lid]
                                                                                                                         {ghc-prim:GHC.Types.Int{(w) tc 3J}}
                                                                                                                         of (wild{v a27g} [lid]
                                                                                                                               :: dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
                                                                                                                         { dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} (dt{v a27R} [lid]
                                                                                                                                                                                                                      :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
                                                                                                                                                                                                                   (ds1{v a27S} [lid]
                                                                                                                                                                                                                      :: [base:GHC.MVar.MVar{tc r1Q2}
                                                                                                                                                                                                                            dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Req{tc r1Q1}])
                                                                                                                                                                                                                   (ds2{v a27T} [lid]
                                                                                                                                                                                                                      :: base:GHC.MVar.MVar{tc r1Q2}
                                                                                                                                                                                                                           ghc-prim:GHC.Types.Bool{(w) tc 3c}) ->
                                                                                                                         ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
                                                                                                                           dt{v a27R} [lid]
                                                                                                                         })
                                                                                                                 {(# ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                       s3{tv a1Zk} [tv],
                                                                                                                     vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                                                                                                       (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                          (base:GHC.ST.ST{tc rE}
                                                                                                                             s3{tv a1Zk} [tv]))
                                                                                                                       (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                          a4{tv a1Zi} [tv]) #)}
                                                                                                                 of (wild{v a27V} [lid]
                                                                                                                       :: ghc-prim:GHC.Types.Int{(w) tc 3J})
                                                                                                                 { ghc-prim:GHC.Types.I#{(w) d 6c} (n#{v a280} [lid]
                                                                                                                                                      :: ghc-prim:GHC.Prim.Int#{(w) tc 3G}) ->
                                                                                                                 case ghc-prim:GHC.Prim.newArray#{(w) v 920} [gid[PrimOp]]
                                                                                                                        @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                             a4{tv a1Zi} [tv])
                                                                                                                        @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                             (base:GHC.ST.ST{tc rE}
                                                                                                                                s3{tv a1Zk} [tv]))
                                                                                                                        n#{v a280} [lid]
                                                                                                                        (base:GHC.Err.error{(w) v 05} [gid]
                                                                                                                           @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                                a4{tv a1Zi} [tv])
                                                                                                                           (ghc-prim:GHC.CString.unpackCString#{v 0k} [gid]
                                                                                                                              "MDist (Vector a) - uninitalised"#))
                                                                                                                        (s4{v a21s} [lid]
                                                                                                                         `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                                   (Sym
                                                                                                                                      (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
                                                                                                                                         <s3{tv a1Zk} [tv]>))
                                                                                                                                 :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                                      s3{tv a1Zk} [tv]
                                                                                                                                      ~#
                                                                                                                                    ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                                      (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                                         (base:GHC.ST.ST{tc rE}
                                                                                                                                            s3{tv a1Zk} [tv]))))
                                                                                                                 {(# ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                       s3{tv a1Zk} [tv],
                                                                                                                     vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                                                                                                       (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                          (base:GHC.ST.ST{tc rE}
                                                                                                                             s3{tv a1Zk} [tv]))
                                                                                                                       (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                          a4{tv a1Zi} [tv]) #)}
                                                                                                                 of (ds1{v a282} [lid]
                                                                                                                       :: (# ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                               (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                                  (base:GHC.ST.ST{tc rE}
                                                                                                                                     s3{tv a1Zk} [tv])),
                                                                                                                             ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
                                                                                                                               (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                                  (base:GHC.ST.ST{tc rE}
                                                                                                                                     s3{tv a1Zk} [tv]))
                                                                                                                               (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                                  a4{tv a1Zi} [tv]) #))
                                                                                                                 { (# (ipv{v a284} [lid]
                                                                                                                         :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                              (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                                 (base:GHC.ST.ST{tc rE}
                                                                                                                                    s3{tv a1Zk} [tv]))), (ipv1{v a285} [lid]
                                                                                                                                                            :: ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
                                                                                                                                                                 (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                                                                    (base:GHC.ST.ST{tc rE}
                                                                                                                                                                       s3{tv a1Zk} [tv]))
                                                                                                                                                                 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                                                                    a4{tv a1Zi} [tv])) #) ->
                                                                                                                 (# ipv{v a284} [lid]
                                                                                                                    `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                              (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
                                                                                                                                 <s3{tv a1Zk} [tv]>)
                                                                                                                            :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                                 (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                                    (base:GHC.ST.ST{tc rE}
                                                                                                                                       s3{tv a1Zk} [tv]))
                                                                                                                                 ~#
                                                                                                                               ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                                                                                                                 s3{tv a1Zk} [tv]),
                                                                                                                    vector-0.9.1:Data.Vector.Mutable.MVector{v rr} [gid[DataCon]]
                                                                                                                      @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                           (base:GHC.ST.ST{tc rE}
                                                                                                                              s3{tv a1Zk} [tv]))
                                                                                                                      @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                           a4{tv a1Zi} [tv])
                                                                                                                      0
                                                                                                                      n#{v a280} [lid]
                                                                                                                      ipv1{v a285} [lid] #)
                                                                                                                 }
                                                                                                                 })
                                                                                                              `cast` (Sym
                                                                                                                        (base:GHC.ST.NTCo:ST{tc rx}[0]
                                                                                                                           <s3{tv a1Zk} [tv]>
                                                                                                                           (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                                                                                                              (Sym
                                                                                                                                 (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
                                                                                                                                    <s3{tv a1Zk} [tv]>))
                                                                                                                              <vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                                 a4{tv a1Zi} [tv]>))
                                                                                                                      :: base:GHC.ST.STRep{tc r1j3}
                                                                                                                           s3{tv a1Zk} [tv]
                                                                                                                           (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                                                                                                              (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                                                                                                                 (base:GHC.ST.ST{tc rE}
                                                                                                                                    s3{tv a1Zk} [tv]))
                                                                                                                              (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                                 a4{tv a1Zi} [tv]))
                                                                                                                           ~#
                                                                                                                         base:GHC.ST.ST{tc rE}
                                                                                                                           s3{tv a1Zk} [tv]
                                                                                                                           (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                                                                                                              s3{tv a1Zk} [tv]
                                                                                                                              (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
                                                                                                                                 a4{tv a1Zi} [tv]))))
    Iface expr = \ @ a4
                   $dUnbox :: vector-0.9.1:Data.Vector.Unboxed.Base.Unbox{tc rW} a4
                   @ s3
                   g :: dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF} ->
                 base:Control.Monad.liftM2{v rC}
                   @ (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                          ghc-prim:GHC.Types.Int{(w) tc 3J} s3)
                   @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
                          s3 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4))
                   @ (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                          (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4) s3)
                   @ (base:GHC.ST.ST{tc rE} s3)
                   (base:GHC.ST.$fMonadST{v rA} @ s3)
                   (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
                      @ a4
                      @ s3)
                   (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v ry}
                      @ s3
                      g)
                     `cast`
                   (Sym (base:GHC.ST.NTCo:ST{tc rx}[0]
                             (Refl s3)
                             (Refl
                                  (dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
                                       ghc-prim:GHC.Types.Int{(w) tc 3J} s3))))
                   (\ s4 :: ghc-prim:GHC.Prim.State#{(w) tc 32q} s3 ->
                    case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw}
                           @ ghc-prim:GHC.Types.Int{(w) tc 3J}
                           @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
                              -> ghc-prim:GHC.Types.Int{(w) tc 3J})
                           ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv}
                           (ghc-prim:GHC.Types.I#{(w) v 6d} 0)
                           (case g of wild { dph-prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} dt ds1 ds2 ->
                            ghc-prim:GHC.Types.I#{(w) v 6d}
                              dt }) of wild { ghc-prim:GHC.Types.I#{(w) d 6c} n# ->
                    case ghc-prim:GHC.Prim.newArray#{(w) v 920}
                           @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
                           @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                  (base:GHC.ST.ST{tc rE} s3))
                           n#
                           (base:GHC.Err.error{(w) v 05}
                              @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
                              (ghc-prim:GHC.CString.unpackCString#{v 0k}
                                 "MDist (Vector a) - uninitalised"#))
                           s4
                             `cast`
                           (ghc-prim:GHC.Prim.State#{(w) tc 32q}
                                (Sym (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
                                          (Refl
                                               s3)))) of ds1 { ghc-prim:GHC.Prim.(#,#){(w) d 84} ipv ipv1 ->
                    (# ipv
                         `cast`
                       (ghc-prim:GHC.Prim.State#{(w) tc 32q}
                            (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
                                 (Refl s3))),
                       vector-0.9.1:Data.Vector.Mutable.MVector{v rr}
                         @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
                                (base:GHC.ST.ST{tc rE} s3))
                         @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
                         0
                         n#
                         ipv1 #) } })
                     `cast`
                   (Sym (base:GHC.ST.NTCo:ST{tc rx}[0]
                             (Refl s3)
                             (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
                                  (Sym (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
                                            (Refl s3)))
                                  (Refl (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)))))

Please report this as a GHC bug:  http://www.haskell.org/ghc/reportabug

make[1]: *** [libraries/dph/dph-prim-par/dist-install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.o] Error 1
make: *** [all] Error 2



Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Simon Peyton Jones
Might be me I guess.. sigh.. maybe I didn't clean enough before validate.  I'll try that now

| -----Original Message-----
| From: ghc-devs-bounces at haskell.org [mailto:ghc-devs-bounces at haskell.org]
| On Behalf Of Ian Lynagh
| Sent: 30 May 2013 15:22
| To: ghc-devs at haskell.org
| Subject: Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]
|
|
| Hi all,
|
| The validate build is failing for me with the below. Does anyone know
| what's up please?
|
|
| Thanks
| Ian
|
|
| ===--- building phase 0
| make -r --no-print-directory -f ghc.mk phase=0 phase_0_builds
| make[1]: Nothing to be done for `phase_0_builds'.
| ===--- building phase 1
| make -r --no-print-directory -f ghc.mk phase=1 phase_1_builds
| ===--- building final phase
| make -r --no-print-directory -f ghc.mk phase=final all
| "inplace/bin/ghc-stage2" -hisuf hi -osuf  o -hcsuf hc -static  -H32m -O -Werror -
| Wall -H64m -O0    -package-name dph-prim-par-0.8.0.1 -hide-all-packages -i -
| ilibraries/dph/dph-prim-par/. -ilibraries/dph/dph-prim-par/dist-install/build -
| ilibraries/dph/dph-prim-par/dist-install/build/autogen -Ilibraries/dph/dph-prim-
| par/dist-install/build -Ilibraries/dph/dph-prim-par/dist-install/build/autogen -
| Ilibraries/dph/dph-prim-par/.    -optP-include -optPlibraries/dph/dph-prim-
| par/dist-install/build/autogen/cabal_macros.h -package base-4.7.0.0 -package
| dph-base-0.8.0.1 -package dph-prim-interface-0.8.0.1 -package dph-prim-seq-
| 0.8.0.1 -package old-time-1.1.0.1 -package random-1.0.1.1 -package vector-
| 0.9.1 -Odph -funbox-strict-fields -fcpr-off -Wall -XHaskell98 -XTypeFamilies -
| XGADTs -XRankNTypes -XBangPatterns -XMagicHash -XUnboxedTuples -
| XTypeOperators -XFlexibleInstances -XFlexibleContexts -O2 -O -dcore-lint -fno-
| warn-deprecated-flags  -no-user-package-db -rtsopts -Wwarn     -odir
| libraries/dph/dph-prim-par/dist-install/build -hidir libraries/dph/dph-prim-
| par/dist-install/build -stubdir libraries/dph/dph-prim-par/dist-install/build  -
| dynamic-too -c libraries/dph/dph-prim-
| par/./Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.hs -o
| libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.o -dyno
| libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.dyn_o
| Var/Type length mismatch:
|     []
|     [s{tv a15I} [tv]]
| ghc-stage2: panic! (the 'impossible' happened)
|   (GHC version 7.7.20130530 for x86_64-unknown-linux):
| Iface Lint failure
|     In interface for dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector
|     Unfolding of dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$fDTVector_$cnew
| MD{v rS}
|       <no location info>: Warning:
|           In the expression: base:Control.Monad.liftM2{v rC} [gid]
|                                @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                     ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|                                @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                                     s3{tv a1Zk} [tv]
|                                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                        a4{tv a1Zi} [tv]))
|                                @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                        a4{tv a1Zi} [tv])
|                                     s3{tv a1Zk} [tv])
|                                @ (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv])
|                                (base:GHC.ST.$fMonadST{v rA} [gid[DFunId]] @ s3{tv a1Zk}
| [tv])
|                                (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
| [gid[DataConWrapper]]
|                                   @ a4{tv a1Zi} [tv] @ s3{tv a1Zk} [tv])
|                                ((dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v ry}
| [gid]
|                                    @ s3{tv a1Zk} [tv] g{v a1Zl} [lid])
|                                 `cast` (Sym
|                                           (base:GHC.ST.NTCo:ST{tc rx}[0]
|                                              <s3{tv a1Zk} [tv]>
|                                              <dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk}
| [tv]>)
|                                         :: base:GHC.ST.STRep{tc r1j3}
|                                              s3{tv a1Zk} [tv]
|                                              (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|                                              ~#
|                                            base:GHC.ST.ST{tc rE}
|                                              s3{tv a1Zk} [tv]
|                                              (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                 s3{tv a1Zk} [tv])))
|                                ((\ (s4{v a21s} [lid]
|                                       :: ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv])
| ->
|                                    case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v
| rw} [gid]
|                                           @ ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                           @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                              -> ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                           ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv} [gid]
|                                           (ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]] 0)
|                                           (case g{v a1Zl} [lid]
|                                            {ghc-prim:GHC.Types.Int{(w) tc 3J}}
|                                            of (wild{v a27g} [lid]
|                                                  :: dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
|                                            { dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} (dt{v
| a27R} [lid]
|
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
|
| (ds1{v a27S} [lid]
|
| :: [base:GHC.MVar.MVar{tc r1Q2}
|
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Req{tc r1Q1}])
|
| (ds2{v a27T} [lid]
|
| :: base:GHC.MVar.MVar{tc r1Q2}
|
| ghc-prim:GHC.Types.Bool{(w) tc 3c}) ->
|                                            ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                              dt{v a27R} [lid]
|                                            })
|                                    {(# ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv],
|                                        vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                          (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                             (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                          (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                             a4{tv a1Zi} [tv]) #)}
|                                    of (wild{v a27V} [lid] :: ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                    { ghc-prim:GHC.Types.I#{(w) d 6c} (n#{v a280} [lid]
|                                                                         :: ghc-prim:GHC.Prim.Int#{(w) tc
| 3G}) ->
|                                    case ghc-prim:GHC.Prim.newArray#{(w) v 920}
| [gid[PrimOp]]
|                                           @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                a4{tv a1Zi} [tv])
|                                           @ (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                           n#{v a280} [lid]
|                                           (base:GHC.Err.error{(w) v 05} [gid]
|                                              @ (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                   a4{tv a1Zi} [tv])
|                                              (ghc-prim:GHC.CString.unpackCString#{v 0k} [gid]
|                                                 "MDist (Vector a) - uninitalised"#))
|                                           (s4{v a21s} [lid]
|                                            `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                      (Sym
|                                                         (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                            <s3{tv a1Zk} [tv]>))
|                                                    :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                         s3{tv a1Zk} [tv]
|                                                         ~#
|                                                       ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                         (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                            (base:GHC.ST.ST{tc rE}
|                                                               s3{tv a1Zk} [tv]))))
|                                    {(# ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv],
|                                        vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                          (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                             (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                          (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                             a4{tv a1Zi} [tv]) #)}
|                                    of (ds1{v a282} [lid]
|                                          :: (# ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                  (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                     (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv])),
|                                                ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
|                                                  (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                     (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                  (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                     a4{tv a1Zi} [tv]) #))
|                                    { (# (ipv{v a284} [lid]
|                                            :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                    (base:GHC.ST.ST{tc rE}
|                                                       s3{tv a1Zk} [tv]))), (ipv1{v a285} [lid]
|                                                                               :: ghc-
| prim:GHC.Prim.MutableArray#{(w) tc 31m}
|                                                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                                                       (base:GHC.ST.ST{tc rE}
|                                                                                          s3{tv a1Zk} [tv]))
|                                                                                    (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                       a4{tv a1Zi} [tv])) #) ->
|                                    (# ipv{v a284} [lid]
|                                       `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                    <s3{tv a1Zk} [tv]>)
|                                               :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                       (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                    ~#
|                                                  ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                    s3{tv a1Zk} [tv]),
|                                       vector-0.9.1:Data.Vector.Mutable.MVector{v rr}
| [gid[DataCon]]
|                                         @ (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                              (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                         @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                              a4{tv a1Zi} [tv])
|                                         0
|                                         n#{v a280} [lid]
|                                         ipv1{v a285} [lid] #)
|                                    }
|                                    })
|                                 `cast` (Sym
|                                           (base:GHC.ST.NTCo:ST{tc rx}[0]
|                                              <s3{tv a1Zk} [tv]>
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 (Sym
|                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                       <s3{tv a1Zk} [tv]>))
|                                                 <vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                    a4{tv a1Zi} [tv]>))
|                                         :: base:GHC.ST.STRep{tc r1j3}
|                                              s3{tv a1Zk} [tv]
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                    (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                    a4{tv a1Zi} [tv]))
|                                              ~#
|                                            base:GHC.ST.ST{tc rE}
|                                              s3{tv a1Zk} [tv]
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 s3{tv a1Zk} [tv]
|                                                 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                    a4{tv a1Zi} [tv]))))
|           Argument value doesn't match argument type:
|           Fun type:
|               (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                  ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]
|                -> vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                     s3{tv a1Zk} [tv]
|                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                        a4{tv a1Zi} [tv])
|                -> dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                        a4{tv a1Zi} [tv])
|                     s3{tv a1Zk} [tv])
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                       ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                       s3{tv a1Zk} [tv]
|                       (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                          a4{tv a1Zi} [tv]))
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                       (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                          a4{tv a1Zi} [tv])
|                       s3{tv a1Zk} [tv])
|           Arg type:
|               dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]
|               -> vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                    s3{tv a1Zk} [tv]
|                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                       a4{tv a1Zi} [tv])
|               -> dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                       a4{tv a1Zi} [tv])
|           Arg:
|               dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
| [gid[DataConWrapper]]
|                 @ a4{tv a1Zi} [tv] @ s3{tv a1Zk} [tv]
|     dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$fDTVector_$cnew
| MD{v rS} = \ (@ a4{tv a1Zi} [tv])
|                                                                                                            ($dUnbox{v
| a1Zj} [lid]
|                                                                                                               :: vector-
| 0.9.1:Data.Vector.Unboxed.Base.Unbox{tc rW}
|                                                                                                                    a4{tv
| a1Zi} [tv])
|                                                                                                            (@ s3{tv
| a1Zk} [tv])
|                                                                                                            (g{v a1Zl}
| [lid]
|                                                                                                               :: dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
| ->
|
| base:Control.Monad.liftM2{v rC} [gid]
|                                                                                                              @ (dph-
| prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc
| rD}
|                                                                                                                   ghc-
| prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                   s3{tv
| a1Zk} [tv])
|                                                                                                              @ (vector-
| 0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                                                                                                                   s3{tv
| a1Zk} [tv]
|                                                                                                                   (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                                                      a4{tv
| a1Zi} [tv]))
|                                                                                                              @ (dph-
| prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc
| rD}
|                                                                                                                   (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                                                      a4{tv
| a1Zi} [tv])
|                                                                                                                   s3{tv
| a1Zk} [tv])
|                                                                                                              @
| (base:GHC.ST.ST{tc rE}
|                                                                                                                   s3{tv
| a1Zk} [tv])
|
| (base:GHC.ST.$fMonadST{v rA} [gid[DFunId]]
|                                                                                                                 @ s3{tv
| a1Zk} [tv])
|                                                                                                              (dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v
| rz} [gid[DataConWrapper]]
|                                                                                                                 @ a4{tv
| a1Zi} [tv]
|                                                                                                                 @ s3{tv
| a1Zk} [tv])
|                                                                                                              ((dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v
| ry} [gid]
|                                                                                                                  @ s3{tv
| a1Zk} [tv]
|                                                                                                                  g{v a1Zl}
| [lid])
|                                                                                                               `cast` (Sym
|
| (base:GHC.ST.NTCo:ST{tc rx}[0]
|
| <s3{tv a1Zk} [tv]>
|
| <dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|
| s3{tv a1Zk} [tv]>)
|                                                                                                                       ::
| base:GHC.ST.STRep{tc r1j3}
|
| s3{tv a1Zk} [tv]
|
| (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|
| s3{tv a1Zk} [tv])
|                                                                                                                            ~#
|
| base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]
|
| (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|
| s3{tv a1Zk} [tv])))
|                                                                                                              ((\ (s4{v
| a21s} [lid]
|                                                                                                                     :: ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                          s3{tv
| a1Zk} [tv]) ->
|                                                                                                                  case
| vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw} [gid]
|                                                                                                                         @
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                         @
| (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                            ->
| ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                                                                                                         ghc-
| prim:GHC.Classes.$fOrdInt_$cmax{v rv} [gid]
|                                                                                                                         (ghc-
| prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                                                                                                            0)
|                                                                                                                         (case
| g{v a1Zl} [lid]
|                                                                                                                          {ghc-
| prim:GHC.Types.Int{(w) tc 3J}}
|                                                                                                                          of
| (wild{v a27g} [lid]
|                                                                                                                                ::
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
|                                                                                                                          {
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} (dt{v
| a27R} [lid]
|
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
|
| (ds1{v a27S} [lid]
|
| :: [base:GHC.MVar.MVar{tc r1Q2}
|
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Req{tc r1Q1}])
|
| (ds2{v a27T} [lid]
|
| :: base:GHC.MVar.MVar{tc r1Q2}
|
| ghc-prim:GHC.Types.Bool{(w) tc 3c}) ->
|                                                                                                                          ghc-
| prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                                                                                                            dt{v
| a27R} [lid]
|                                                                                                                          })
|                                                                                                                  {(# ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                        s3{tv
| a1Zk} [tv],
|                                                                                                                      vector-
| 0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]) #)}
|                                                                                                                  of (wild{v
| a27V} [lid]
|                                                                                                                        :: ghc-
| prim:GHC.Types.Int{(w) tc 3J})
|                                                                                                                  { ghc-
| prim:GHC.Types.I#{(w) d 6c} (n#{v a280} [lid]
|
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G}) ->
|                                                                                                                  case ghc-
| prim:GHC.Prim.newArray#{(w) v 920} [gid[PrimOp]]
|                                                                                                                         @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])
|                                                                                                                         @
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|                                                                                                                         n#{v
| a280} [lid]
|
| (base:GHC.Err.error{(w) v 05} [gid]
|                                                                                                                            @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])
|
| (ghc-prim:GHC.CString.unpackCString#{v 0k} [gid]
|
| "MDist (Vector a) - uninitalised"#))
|                                                                                                                         (s4{v
| a21s} [lid]
|
| `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (Sym
|
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|
| <s3{tv a1Zk} [tv]>))
|
| :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| s3{tv a1Zk} [tv]
|
| ~#
|
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))))
|                                                                                                                  {(# ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                        s3{tv
| a1Zk} [tv],
|                                                                                                                      vector-
| 0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]) #)}
|                                                                                                                  of (ds1{v
| a282} [lid]
|                                                                                                                        :: (#
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv])),
|
| ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]) #))
|                                                                                                                  { (# (ipv{v
| a284} [lid]
|                                                                                                                          ::
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))), (ipv1{v a285} [lid]
|
| :: ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])) #) ->
|                                                                                                                  (# ipv{v
| a284} [lid]
|                                                                                                                     `cast`
| (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|
| <s3{tv a1Zk} [tv]>)
|                                                                                                                             ::
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| ~#
|
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| s3{tv a1Zk} [tv]),
|                                                                                                                     vector-
| 0.9.1:Data.Vector.Mutable.MVector{v rr} [gid[DataCon]]
|                                                                                                                       @
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|                                                                                                                       @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])
|                                                                                                                       0
|                                                                                                                       n#{v
| a280} [lid]
|                                                                                                                       ipv1{v
| a285} [lid] #)
|                                                                                                                  }
|                                                                                                                  })
|                                                                                                               `cast` (Sym
|
| (base:GHC.ST.NTCo:ST{tc rx}[0]
|
| <s3{tv a1Zk} [tv]>
|
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (Sym
|
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|
| <s3{tv a1Zk} [tv]>))
|
| <vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]>))
|                                                                                                                       ::
| base:GHC.ST.STRep{tc r1j3}
|
| s3{tv a1Zk} [tv]
|
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]))
|                                                                                                                            ~#
|
| base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]
|
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| s3{tv a1Zk} [tv]
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]))))
|     Iface expr = \ @ a4
|                    $dUnbox :: vector-0.9.1:Data.Vector.Unboxed.Base.Unbox{tc rW} a4
|                    @ s3
|                    g :: dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF} ->
|                  base:Control.Monad.liftM2{v rC}
|                    @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                           ghc-prim:GHC.Types.Int{(w) tc 3J} s3)
|                    @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                           s3 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4))
|                    @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                           (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4) s3)
|                    @ (base:GHC.ST.ST{tc rE} s3)
|                    (base:GHC.ST.$fMonadST{v rA} @ s3)
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
|                       @ a4
|                       @ s3)
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v ry}
|                       @ s3
|                       g)
|                      `cast`
|                    (Sym (base:GHC.ST.NTCo:ST{tc rx}[0]
|                              (Refl s3)
|                              (Refl
|                                   (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                        ghc-prim:GHC.Types.Int{(w) tc 3J} s3))))
|                    (\ s4 :: ghc-prim:GHC.Prim.State#{(w) tc 32q} s3 ->
|                     case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw}
|                            @ ghc-prim:GHC.Types.Int{(w) tc 3J}
|                            @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                               -> ghc-prim:GHC.Types.Int{(w) tc 3J})
|                            ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv}
|                            (ghc-prim:GHC.Types.I#{(w) v 6d} 0)
|                            (case g of wild { dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} dt
| ds1 ds2 ->
|                             ghc-prim:GHC.Types.I#{(w) v 6d}
|                               dt }) of wild { ghc-prim:GHC.Types.I#{(w) d 6c} n# ->
|                     case ghc-prim:GHC.Prim.newArray#{(w) v 920}
|                            @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                            @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                   (base:GHC.ST.ST{tc rE} s3))
|                            n#
|                            (base:GHC.Err.error{(w) v 05}
|                               @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                               (ghc-prim:GHC.CString.unpackCString#{v 0k}
|                                  "MDist (Vector a) - uninitalised"#))
|                            s4
|                              `cast`
|                            (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                 (Sym (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                           (Refl
|                                                s3)))) of ds1 { ghc-prim:GHC.Prim.(#,#){(w) d 84}
| ipv ipv1 ->
|                     (# ipv
|                          `cast`
|                        (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                             (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                  (Refl s3))),
|                        vector-0.9.1:Data.Vector.Mutable.MVector{v rr}
|                          @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                 (base:GHC.ST.ST{tc rE} s3))
|                          @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                          0
|                          n#
|                          ipv1 #) } })
|                      `cast`
|                    (Sym (base:GHC.ST.NTCo:ST{tc rx}[0]
|                              (Refl s3)
|                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                   (Sym (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                             (Refl s3)))
|                                   (Refl (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU} a4)))))
|
| Please report this as a GHC bug:  http://www.haskell.org/ghc/reportabug
|
| make[1]: *** [libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.o] Error
| 1
| make: *** [all] Error 2
|
|
| _______________________________________________
| ghc-devs mailing list
| ghc-devs at haskell.org
| http://www.haskell.org/mailman/listinfo/ghc-devs


Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Simon Peyton Jones
In reply to this post by Ian Lynagh-2
I can reproduce it.  It's very likely my fault.  Stay tuned.  But I have to go to London tomorrow.  Apols

| -----Original Message-----
| From: ghc-devs-bounces at haskell.org [mailto:ghc-devs-bounces at haskell.org]
| On Behalf Of Ian Lynagh
| Sent: 30 May 2013 15:22
| To: ghc-devs at haskell.org
| Subject: Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]
|
|
| Hi all,
|
| The validate build is failing for me with the below. Does anyone know
| what's up please?
|
|
| Thanks
| Ian
|
|
| ===--- building phase 0
| make -r --no-print-directory -f ghc.mk phase=0 phase_0_builds
| make[1]: Nothing to be done for `phase_0_builds'.
| ===--- building phase 1
| make -r --no-print-directory -f ghc.mk phase=1 phase_1_builds
| ===--- building final phase
| make -r --no-print-directory -f ghc.mk phase=final all
| "inplace/bin/ghc-stage2" -hisuf hi -osuf  o -hcsuf hc -static  -H32m -O -Werror -
| Wall -H64m -O0    -package-name dph-prim-par-0.8.0.1 -hide-all-packages -i -
| ilibraries/dph/dph-prim-par/. -ilibraries/dph/dph-prim-par/dist-install/build -
| ilibraries/dph/dph-prim-par/dist-install/build/autogen -Ilibraries/dph/dph-prim-
| par/dist-install/build -Ilibraries/dph/dph-prim-par/dist-install/build/autogen -
| Ilibraries/dph/dph-prim-par/.    -optP-include -optPlibraries/dph/dph-prim-
| par/dist-install/build/autogen/cabal_macros.h -package base-4.7.0.0 -package
| dph-base-0.8.0.1 -package dph-prim-interface-0.8.0.1 -package dph-prim-seq-
| 0.8.0.1 -package old-time-1.1.0.1 -package random-1.0.1.1 -package vector-
| 0.9.1 -Odph -funbox-strict-fields -fcpr-off -Wall -XHaskell98 -XTypeFamilies -
| XGADTs -XRankNTypes -XBangPatterns -XMagicHash -XUnboxedTuples -
| XTypeOperators -XFlexibleInstances -XFlexibleContexts -O2 -O -dcore-lint -fno-
| warn-deprecated-flags  -no-user-package-db -rtsopts -Wwarn     -odir
| libraries/dph/dph-prim-par/dist-install/build -hidir libraries/dph/dph-prim-
| par/dist-install/build -stubdir libraries/dph/dph-prim-par/dist-install/build  -
| dynamic-too -c libraries/dph/dph-prim-
| par/./Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.hs -o
| libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.o -dyno
| libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.dyn_o
| Var/Type length mismatch:
|     []
|     [s{tv a15I} [tv]]
| ghc-stage2: panic! (the 'impossible' happened)
|   (GHC version 7.7.20130530 for x86_64-unknown-linux):
| Iface Lint failure
|     In interface for dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector
|     Unfolding of dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$fDTVector_$cnew
| MD{v rS}
|       <no location info>: Warning:
|           In the expression: base:Control.Monad.liftM2{v rC} [gid]
|                                @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                     ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|                                @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                                     s3{tv a1Zk} [tv]
|                                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                        a4{tv a1Zi} [tv]))
|                                @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                        a4{tv a1Zi} [tv])
|                                     s3{tv a1Zk} [tv])
|                                @ (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv])
|                                (base:GHC.ST.$fMonadST{v rA} [gid[DFunId]] @ s3{tv a1Zk}
| [tv])
|                                (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
| [gid[DataConWrapper]]
|                                   @ a4{tv a1Zi} [tv] @ s3{tv a1Zk} [tv])
|                                ((dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v ry}
| [gid]
|                                    @ s3{tv a1Zk} [tv] g{v a1Zl} [lid])
|                                 `cast` (Sym
|                                           (base:GHC.ST.NTCo:ST{tc rx}[0]
|                                              <s3{tv a1Zk} [tv]>
|                                              <dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk}
| [tv]>)
|                                         :: base:GHC.ST.STRep{tc r1j3}
|                                              s3{tv a1Zk} [tv]
|                                              (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|                                              ~#
|                                            base:GHC.ST.ST{tc rE}
|                                              s3{tv a1Zk} [tv]
|                                              (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                 s3{tv a1Zk} [tv])))
|                                ((\ (s4{v a21s} [lid]
|                                       :: ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv])
| ->
|                                    case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v
| rw} [gid]
|                                           @ ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                           @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                              -> ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                           ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv} [gid]
|                                           (ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]] 0)
|                                           (case g{v a1Zl} [lid]
|                                            {ghc-prim:GHC.Types.Int{(w) tc 3J}}
|                                            of (wild{v a27g} [lid]
|                                                  :: dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
|                                            { dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} (dt{v
| a27R} [lid]
|
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
|
| (ds1{v a27S} [lid]
|
| :: [base:GHC.MVar.MVar{tc r1Q2}
|
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Req{tc r1Q1}])
|
| (ds2{v a27T} [lid]
|
| :: base:GHC.MVar.MVar{tc r1Q2}
|
| ghc-prim:GHC.Types.Bool{(w) tc 3c}) ->
|                                            ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                              dt{v a27R} [lid]
|                                            })
|                                    {(# ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv],
|                                        vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                          (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                             (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                          (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                             a4{tv a1Zi} [tv]) #)}
|                                    of (wild{v a27V} [lid] :: ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                    { ghc-prim:GHC.Types.I#{(w) d 6c} (n#{v a280} [lid]
|                                                                         :: ghc-prim:GHC.Prim.Int#{(w) tc
| 3G}) ->
|                                    case ghc-prim:GHC.Prim.newArray#{(w) v 920}
| [gid[PrimOp]]
|                                           @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                a4{tv a1Zi} [tv])
|                                           @ (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                           n#{v a280} [lid]
|                                           (base:GHC.Err.error{(w) v 05} [gid]
|                                              @ (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                   a4{tv a1Zi} [tv])
|                                              (ghc-prim:GHC.CString.unpackCString#{v 0k} [gid]
|                                                 "MDist (Vector a) - uninitalised"#))
|                                           (s4{v a21s} [lid]
|                                            `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                      (Sym
|                                                         (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                            <s3{tv a1Zk} [tv]>))
|                                                    :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                         s3{tv a1Zk} [tv]
|                                                         ~#
|                                                       ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                         (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                            (base:GHC.ST.ST{tc rE}
|                                                               s3{tv a1Zk} [tv]))))
|                                    {(# ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv],
|                                        vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                          (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                             (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                          (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                             a4{tv a1Zi} [tv]) #)}
|                                    of (ds1{v a282} [lid]
|                                          :: (# ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                  (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                     (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv])),
|                                                ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
|                                                  (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                     (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                  (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                     a4{tv a1Zi} [tv]) #))
|                                    { (# (ipv{v a284} [lid]
|                                            :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                    (base:GHC.ST.ST{tc rE}
|                                                       s3{tv a1Zk} [tv]))), (ipv1{v a285} [lid]
|                                                                               :: ghc-
| prim:GHC.Prim.MutableArray#{(w) tc 31m}
|                                                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                                                       (base:GHC.ST.ST{tc rE}
|                                                                                          s3{tv a1Zk} [tv]))
|                                                                                    (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                       a4{tv a1Zi} [tv])) #) ->
|                                    (# ipv{v a284} [lid]
|                                       `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                    <s3{tv a1Zk} [tv]>)
|                                               :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                       (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                    ~#
|                                                  ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                    s3{tv a1Zk} [tv]),
|                                       vector-0.9.1:Data.Vector.Mutable.MVector{v rr}
| [gid[DataCon]]
|                                         @ (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                              (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                         @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                              a4{tv a1Zi} [tv])
|                                         0
|                                         n#{v a280} [lid]
|                                         ipv1{v a285} [lid] #)
|                                    }
|                                    })
|                                 `cast` (Sym
|                                           (base:GHC.ST.NTCo:ST{tc rx}[0]
|                                              <s3{tv a1Zk} [tv]>
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 (Sym
|                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                       <s3{tv a1Zk} [tv]>))
|                                                 <vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                    a4{tv a1Zi} [tv]>))
|                                         :: base:GHC.ST.STRep{tc r1j3}
|                                              s3{tv a1Zk} [tv]
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                    (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                    a4{tv a1Zi} [tv]))
|                                              ~#
|                                            base:GHC.ST.ST{tc rE}
|                                              s3{tv a1Zk} [tv]
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 s3{tv a1Zk} [tv]
|                                                 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                    a4{tv a1Zi} [tv]))))
|           Argument value doesn't match argument type:
|           Fun type:
|               (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                  ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]
|                -> vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                     s3{tv a1Zk} [tv]
|                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                        a4{tv a1Zi} [tv])
|                -> dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                        a4{tv a1Zi} [tv])
|                     s3{tv a1Zk} [tv])
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                       ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                       s3{tv a1Zk} [tv]
|                       (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                          a4{tv a1Zi} [tv]))
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                       (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                          a4{tv a1Zi} [tv])
|                       s3{tv a1Zk} [tv])
|           Arg type:
|               dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]
|               -> vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                    s3{tv a1Zk} [tv]
|                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                       a4{tv a1Zi} [tv])
|               -> dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                       a4{tv a1Zi} [tv])
|           Arg:
|               dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
| [gid[DataConWrapper]]
|                 @ a4{tv a1Zi} [tv] @ s3{tv a1Zk} [tv]
|     dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$fDTVector_$cnew
| MD{v rS} = \ (@ a4{tv a1Zi} [tv])
|                                                                                                            ($dUnbox{v
| a1Zj} [lid]
|                                                                                                               :: vector-
| 0.9.1:Data.Vector.Unboxed.Base.Unbox{tc rW}
|                                                                                                                    a4{tv
| a1Zi} [tv])
|                                                                                                            (@ s3{tv
| a1Zk} [tv])
|                                                                                                            (g{v a1Zl}
| [lid]
|                                                                                                               :: dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
| ->
|
| base:Control.Monad.liftM2{v rC} [gid]
|                                                                                                              @ (dph-
| prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc
| rD}
|                                                                                                                   ghc-
| prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                   s3{tv
| a1Zk} [tv])
|                                                                                                              @ (vector-
| 0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                                                                                                                   s3{tv
| a1Zk} [tv]
|                                                                                                                   (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                                                      a4{tv
| a1Zi} [tv]))
|                                                                                                              @ (dph-
| prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc
| rD}
|                                                                                                                   (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                                                      a4{tv
| a1Zi} [tv])
|                                                                                                                   s3{tv
| a1Zk} [tv])
|                                                                                                              @
| (base:GHC.ST.ST{tc rE}
|                                                                                                                   s3{tv
| a1Zk} [tv])
|
| (base:GHC.ST.$fMonadST{v rA} [gid[DFunId]]
|                                                                                                                 @ s3{tv
| a1Zk} [tv])
|                                                                                                              (dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v
| rz} [gid[DataConWrapper]]
|                                                                                                                 @ a4{tv
| a1Zi} [tv]
|                                                                                                                 @ s3{tv
| a1Zk} [tv])
|                                                                                                              ((dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v
| ry} [gid]
|                                                                                                                  @ s3{tv
| a1Zk} [tv]
|                                                                                                                  g{v a1Zl}
| [lid])
|                                                                                                               `cast` (Sym
|
| (base:GHC.ST.NTCo:ST{tc rx}[0]
|
| <s3{tv a1Zk} [tv]>
|
| <dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|
| s3{tv a1Zk} [tv]>)
|                                                                                                                       ::
| base:GHC.ST.STRep{tc r1j3}
|
| s3{tv a1Zk} [tv]
|
| (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|
| s3{tv a1Zk} [tv])
|                                                                                                                            ~#
|
| base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]
|
| (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|
| s3{tv a1Zk} [tv])))
|                                                                                                              ((\ (s4{v
| a21s} [lid]
|                                                                                                                     :: ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                          s3{tv
| a1Zk} [tv]) ->
|                                                                                                                  case
| vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw} [gid]
|                                                                                                                         @
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                         @
| (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                            ->
| ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                                                                                                         ghc-
| prim:GHC.Classes.$fOrdInt_$cmax{v rv} [gid]
|                                                                                                                         (ghc-
| prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                                                                                                            0)
|                                                                                                                         (case
| g{v a1Zl} [lid]
|                                                                                                                          {ghc-
| prim:GHC.Types.Int{(w) tc 3J}}
|                                                                                                                          of
| (wild{v a27g} [lid]
|                                                                                                                                ::
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
|                                                                                                                          {
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} (dt{v
| a27R} [lid]
|
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
|
| (ds1{v a27S} [lid]
|
| :: [base:GHC.MVar.MVar{tc r1Q2}
|
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Req{tc r1Q1}])
|
| (ds2{v a27T} [lid]
|
| :: base:GHC.MVar.MVar{tc r1Q2}
|
| ghc-prim:GHC.Types.Bool{(w) tc 3c}) ->
|                                                                                                                          ghc-
| prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                                                                                                            dt{v
| a27R} [lid]
|                                                                                                                          })
|                                                                                                                  {(# ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                        s3{tv
| a1Zk} [tv],
|                                                                                                                      vector-
| 0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]) #)}
|                                                                                                                  of (wild{v
| a27V} [lid]
|                                                                                                                        :: ghc-
| prim:GHC.Types.Int{(w) tc 3J})
|                                                                                                                  { ghc-
| prim:GHC.Types.I#{(w) d 6c} (n#{v a280} [lid]
|
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G}) ->
|                                                                                                                  case ghc-
| prim:GHC.Prim.newArray#{(w) v 920} [gid[PrimOp]]
|                                                                                                                         @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])
|                                                                                                                         @
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|                                                                                                                         n#{v
| a280} [lid]
|
| (base:GHC.Err.error{(w) v 05} [gid]
|                                                                                                                            @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])
|
| (ghc-prim:GHC.CString.unpackCString#{v 0k} [gid]
|
| "MDist (Vector a) - uninitalised"#))
|                                                                                                                         (s4{v
| a21s} [lid]
|
| `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (Sym
|
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|
| <s3{tv a1Zk} [tv]>))
|
| :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| s3{tv a1Zk} [tv]
|
| ~#
|
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))))
|                                                                                                                  {(# ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                        s3{tv
| a1Zk} [tv],
|                                                                                                                      vector-
| 0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]) #)}
|                                                                                                                  of (ds1{v
| a282} [lid]
|                                                                                                                        :: (#
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv])),
|
| ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]) #))
|                                                                                                                  { (# (ipv{v
| a284} [lid]
|                                                                                                                          ::
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))), (ipv1{v a285} [lid]
|
| :: ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])) #) ->
|                                                                                                                  (# ipv{v
| a284} [lid]
|                                                                                                                     `cast`
| (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|
| <s3{tv a1Zk} [tv]>)
|                                                                                                                             ::
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| ~#
|
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| s3{tv a1Zk} [tv]),
|                                                                                                                     vector-
| 0.9.1:Data.Vector.Mutable.MVector{v rr} [gid[DataCon]]
|                                                                                                                       @
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|                                                                                                                       @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])
|                                                                                                                       0
|                                                                                                                       n#{v
| a280} [lid]
|                                                                                                                       ipv1{v
| a285} [lid] #)
|                                                                                                                  }
|                                                                                                                  })
|                                                                                                               `cast` (Sym
|
| (base:GHC.ST.NTCo:ST{tc rx}[0]
|
| <s3{tv a1Zk} [tv]>
|
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (Sym
|
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|
| <s3{tv a1Zk} [tv]>))
|
| <vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]>))
|                                                                                                                       ::
| base:GHC.ST.STRep{tc r1j3}
|
| s3{tv a1Zk} [tv]
|
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]))
|                                                                                                                            ~#
|
| base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]
|
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| s3{tv a1Zk} [tv]
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]))))
|     Iface expr = \ @ a4
|                    $dUnbox :: vector-0.9.1:Data.Vector.Unboxed.Base.Unbox{tc rW} a4
|                    @ s3
|                    g :: dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF} ->
|                  base:Control.Monad.liftM2{v rC}
|                    @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                           ghc-prim:GHC.Types.Int{(w) tc 3J} s3)
|                    @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                           s3 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4))
|                    @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                           (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4) s3)
|                    @ (base:GHC.ST.ST{tc rE} s3)
|                    (base:GHC.ST.$fMonadST{v rA} @ s3)
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
|                       @ a4
|                       @ s3)
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v ry}
|                       @ s3
|                       g)
|                      `cast`
|                    (Sym (base:GHC.ST.NTCo:ST{tc rx}[0]
|                              (Refl s3)
|                              (Refl
|                                   (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                        ghc-prim:GHC.Types.Int{(w) tc 3J} s3))))
|                    (\ s4 :: ghc-prim:GHC.Prim.State#{(w) tc 32q} s3 ->
|                     case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw}
|                            @ ghc-prim:GHC.Types.Int{(w) tc 3J}
|                            @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                               -> ghc-prim:GHC.Types.Int{(w) tc 3J})
|                            ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv}
|                            (ghc-prim:GHC.Types.I#{(w) v 6d} 0)
|                            (case g of wild { dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d ru} dt
| ds1 ds2 ->
|                             ghc-prim:GHC.Types.I#{(w) v 6d}
|                               dt }) of wild { ghc-prim:GHC.Types.I#{(w) d 6c} n# ->
|                     case ghc-prim:GHC.Prim.newArray#{(w) v 920}
|                            @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                            @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                   (base:GHC.ST.ST{tc rE} s3))
|                            n#
|                            (base:GHC.Err.error{(w) v 05}
|                               @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                               (ghc-prim:GHC.CString.unpackCString#{v 0k}
|                                  "MDist (Vector a) - uninitalised"#))
|                            s4
|                              `cast`
|                            (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                 (Sym (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                           (Refl
|                                                s3)))) of ds1 { ghc-prim:GHC.Prim.(#,#){(w) d 84}
| ipv ipv1 ->
|                     (# ipv
|                          `cast`
|                        (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                             (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                  (Refl s3))),
|                        vector-0.9.1:Data.Vector.Mutable.MVector{v rr}
|                          @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                 (base:GHC.ST.ST{tc rE} s3))
|                          @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                          0
|                          n#
|                          ipv1 #) } })
|                      `cast`
|                    (Sym (base:GHC.ST.NTCo:ST{tc rx}[0]
|                              (Refl s3)
|                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                   (Sym (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                             (Refl s3)))
|                                   (Refl (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU} a4)))))
|
| Please report this as a GHC bug:  http://www.haskell.org/ghc/reportabug
|
| make[1]: *** [libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.o] Error
| 1
| make: *** [all] Error 2
|
|
| _______________________________________________
| ghc-devs mailing list
| ghc-devs at haskell.org
| http://www.haskell.org/mailman/listinfo/ghc-devs


Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Simon Peyton Jones
I've pushed a fix.

Simon

-----Original Message-----
From: Simon Peyton-Jones
Sent: 30 May 2013 17:37
To: Ian Lynagh; ghc-devs at haskell.org
Subject: RE: Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

I can reproduce it.  It's very likely my fault.  Stay tuned.  But I have to go to London tomorrow.  Apols

| -----Original Message-----
| From: ghc-devs-bounces at haskell.org
| [mailto:ghc-devs-bounces at haskell.org]
| On Behalf Of Ian Lynagh
| Sent: 30 May 2013 15:22
| To: ghc-devs at haskell.org
| Subject: Validate fails: Var/Type length mismatch: [] [s{tv a15I}
| [tv]]
|
|
| Hi all,
|
| The validate build is failing for me with the below. Does anyone know
| what's up please?
|
|
| Thanks
| Ian
|
|
| ===--- building phase 0
| make -r --no-print-directory -f ghc.mk phase=0 phase_0_builds
| make[1]: Nothing to be done for `phase_0_builds'.
| ===--- building phase 1
| make -r --no-print-directory -f ghc.mk phase=1 phase_1_builds
| ===--- building final phase
| make -r --no-print-directory -f ghc.mk phase=final all
| "inplace/bin/ghc-stage2" -hisuf hi -osuf  o -hcsuf hc -static  -H32m -O -Werror -
| Wall -H64m -O0    -package-name dph-prim-par-0.8.0.1 -hide-all-packages -i -
| ilibraries/dph/dph-prim-par/.
| -ilibraries/dph/dph-prim-par/dist-install/build -
| ilibraries/dph/dph-prim-par/dist-install/build/autogen -Ilibraries/dph/dph-prim- par/dist-install/build -Ilibraries/dph/dph-prim-par/dist-install/build/autogen -
| Ilibraries/dph/dph-prim-par/.    -optP-include -optPlibraries/dph/dph-prim-
| par/dist-install/build/autogen/cabal_macros.h -package base-4.7.0.0
| -package
| dph-base-0.8.0.1 -package dph-prim-interface-0.8.0.1 -package
| dph-prim-seq-
| 0.8.0.1 -package old-time-1.1.0.1 -package random-1.0.1.1 -package
| vector-
| 0.9.1 -Odph -funbox-strict-fields -fcpr-off -Wall -XHaskell98
| -XTypeFamilies - XGADTs -XRankNTypes -XBangPatterns -XMagicHash
| -XUnboxedTuples - XTypeOperators -XFlexibleInstances -XFlexibleContexts -O2 -O -dcore-lint -fno-
| warn-deprecated-flags  -no-user-package-db -rtsopts -Wwarn     -odir
| libraries/dph/dph-prim-par/dist-install/build -hidir
| libraries/dph/dph-prim- par/dist-install/build -stubdir
| libraries/dph/dph-prim-par/dist-install/build  - dynamic-too -c
| libraries/dph/dph-prim-
| par/./Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.hs -o
| libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.o
| -dyno
| libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.d
| yn_o
| Var/Type length mismatch:
|     []
|     [s{tv a15I} [tv]]
| ghc-stage2: panic! (the 'impossible' happened)
|   (GHC version 7.7.20130530 for x86_64-unknown-linux):
| Iface Lint failure
|     In interface for dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector
|     Unfolding of dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$fDTVecto
| r_$cnew
| MD{v rS}
|       <no location info>: Warning:
|           In the expression: base:Control.Monad.liftM2{v rC} [gid]
|                                @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                     ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|                                @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                                     s3{tv a1Zk} [tv]
|                                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                        a4{tv a1Zi} [tv]))
|                                @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                        a4{tv a1Zi} [tv])
|                                     s3{tv a1Zk} [tv])
|                                @ (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv])
|                                (base:GHC.ST.$fMonadST{v rA}
| [gid[DFunId]] @ s3{tv a1Zk}
| [tv])
|                                (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVecto
| r{v rz} [gid[DataConWrapper]]
|                                   @ a4{tv a1Zi} [tv] @ s3{tv a1Zk} [tv])
|                                ((dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDT
| Int8{v ry} [gid]
|                                    @ s3{tv a1Zk} [tv] g{v a1Zl} [lid])
|                                 `cast` (Sym
|                                           (base:GHC.ST.NTCo:ST{tc rx}[0]
|                                              <s3{tv a1Zk} [tv]>
|                                              <dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                
| ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk}
| [tv]>)
|                                         :: base:GHC.ST.STRep{tc r1j3}
|                                              s3{tv a1Zk} [tv]
|                                              (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|                                              ~#
|                                            base:GHC.ST.ST{tc rE}
|                                              s3{tv a1Zk} [tv]
|                                              (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                                 ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                 s3{tv a1Zk} [tv])))
|                                ((\ (s4{v a21s} [lid]
|                                       :: ghc-prim:GHC.Prim.State#{(w)
| tc 32q} s3{tv a1Zk} [tv])
| ->
|                                    case
| vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v
| rw} [gid]
|                                           @ ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                           @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                              -> ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                           ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv} [gid]
|                                           (ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]] 0)
|                                           (case g{v a1Zl} [lid]
|                                            {ghc-prim:GHC.Types.Int{(w) tc 3J}}
|                                            of (wild{v a27g} [lid]
|                                                  :: dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
|                                            { dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d
| ru} (dt{v a27R} [lid]
|
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
|
| (ds1{v a27S} [lid]
|
| :: [base:GHC.MVar.MVar{tc r1Q2}
|
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Req{tc
| r1Q1}])
|
| (ds2{v a27T} [lid]
|
| :: base:GHC.MVar.MVar{tc r1Q2}
|
| ghc-prim:GHC.Types.Bool{(w) tc 3c}) ->
|                                            ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                              dt{v a27R} [lid]
|                                            })
|                                    {(# ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv],
|                                        vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                          (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                             (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                          (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                             a4{tv a1Zi} [tv]) #)}
|                                    of (wild{v a27V} [lid] :: ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                    { ghc-prim:GHC.Types.I#{(w) d 6c} (n#{v a280} [lid]
|                                                                        
| :: ghc-prim:GHC.Prim.Int#{(w) tc
| 3G}) ->
|                                    case
| ghc-prim:GHC.Prim.newArray#{(w) v 920} [gid[PrimOp]]
|                                           @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                a4{tv a1Zi} [tv])
|                                           @ (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                           n#{v a280} [lid]
|                                           (base:GHC.Err.error{(w) v 05} [gid]
|                                              @ (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                   a4{tv a1Zi} [tv])
|                                              (ghc-prim:GHC.CString.unpackCString#{v 0k} [gid]
|                                                 "MDist (Vector a) - uninitalised"#))
|                                           (s4{v a21s} [lid]
|                                            `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                      (Sym
|                                                         (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                            <s3{tv a1Zk} [tv]>))
|                                                    :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                         s3{tv a1Zk} [tv]
|                                                         ~#
|                                                       ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                         (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                            (base:GHC.ST.ST{tc rE}
|                                                               s3{tv a1Zk} [tv]))))
|                                    {(# ghc-prim:GHC.Prim.State#{(w) tc 32q} s3{tv a1Zk} [tv],
|                                        vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                          (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                             (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                          (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                             a4{tv a1Zi} [tv]) #)}
|                                    of (ds1{v a282} [lid]
|                                          :: (# ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                  (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                     (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv])),
|                                                ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
|                                                  (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                     (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                  (vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                     a4{tv a1Zi} [tv]) #))
|                                    { (# (ipv{v a284} [lid]
|                                            :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                    (base:GHC.ST.ST{tc rE}
|                                                       s3{tv a1Zk} [tv]))), (ipv1{v a285} [lid]
|                                                                              
| :: ghc-
| prim:GHC.Prim.MutableArray#{(w) tc 31m}
|                                                                                    
| (primitive- 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                                                       (base:GHC.ST.ST{tc rE}
|                                                                                          s3{tv a1Zk} [tv]))
|                                                                                    
| (vector- 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                       a4{tv a1Zi} [tv])) #) ->
|                                    (# ipv{v a284} [lid]
|                                       `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                    <s3{tv a1Zk} [tv]>)
|                                               :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                       (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                    ~#
|                                                  ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                                    s3{tv a1Zk} [tv]),
|                                      
| vector-0.9.1:Data.Vector.Mutable.MVector{v rr} [gid[DataCon]]
|                                         @ (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                              (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                         @
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                              a4{tv a1Zi} [tv])
|                                         0
|                                         n#{v a280} [lid]
|                                         ipv1{v a285} [lid] #)
|                                    }
|                                    })
|                                 `cast` (Sym
|                                           (base:GHC.ST.NTCo:ST{tc rx}[0]
|                                              <s3{tv a1Zk} [tv]>
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 (Sym
|                                                    (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                                       <s3{tv a1Zk} [tv]>))
|                                                 <vector-
| 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                    a4{tv a1Zi} [tv]>))
|                                         :: base:GHC.ST.STRep{tc r1j3}
|                                              s3{tv a1Zk} [tv]
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 (primitive-
| 0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                                    (base:GHC.ST.ST{tc rE} s3{tv a1Zk} [tv]))
|                                                
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                    a4{tv a1Zi} [tv]))
|                                              ~#
|                                            base:GHC.ST.ST{tc rE}
|                                              s3{tv a1Zk} [tv]
|                                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                                 s3{tv a1Zk} [tv]
|                                                
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU}
|                                                    a4{tv a1Zi} [tv]))))
|           Argument value doesn't match argument type:
|           Fun type:
|               (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                  ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]
|                -> vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                     s3{tv a1Zk} [tv]
|                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                        a4{tv a1Zi} [tv])
|                -> dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                     (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                        a4{tv a1Zi} [tv])
|                     s3{tv a1Zk} [tv])
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                       ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv])
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                       s3{tv a1Zk} [tv]
|                       (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                          a4{tv a1Zi} [tv]))
|               -> base:GHC.ST.ST{tc rE}
|                    s3{tv a1Zk} [tv]
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                       (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                          a4{tv a1Zi} [tv])
|                       s3{tv a1Zk} [tv])
|           Arg type:
|               dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                 ghc-prim:GHC.Types.Int{(w) tc 3J} s3{tv a1Zk} [tv]
|               -> vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                    s3{tv a1Zk} [tv]
|                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                       a4{tv a1Zi} [tv])
|               -> dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                    (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                       a4{tv a1Zi} [tv])
|           Arg:
|               dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVecto
| r{v rz} [gid[DataConWrapper]]
|                 @ a4{tv a1Zi} [tv] @ s3{tv a1Zk} [tv]
|     dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$fDTVecto
| r_$cnew
| MD{v rS} = \ (@ a4{tv a1Zi} [tv])
|                                                                                                            
| ($dUnbox{v a1Zj} [lid]
|                                                                                                              
| :: vector- 0.9.1:Data.Vector.Unboxed.Base.Unbox{tc rW}
|                                                                                                                    
| a4{tv a1Zi} [tv])
|                                                                                                            
| (@ s3{tv a1Zk} [tv])
|                                                                                                            
| (g{v a1Zl} [lid]
|                                                                                                              
| :: dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Ga
| ng{tc rF})
| ->
|
| base:Control.Monad.liftM2{v rC} [gid]
|                                                                                                              
| @ (dph-
| prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT
| .MDist{tc
| rD}
|                                                                                                                  
| ghc-
| prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                  
| s3{tv a1Zk} [tv])
|                                                                                                              
| @ (vector- 0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                                                                                                                  
| s3{tv a1Zk} [tv]
|                                                                                                                  
| (vector- 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                                                      
| a4{tv a1Zi} [tv]))
|                                                                                                              
| @ (dph-
| prim-par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT
| .MDist{tc
| rD}
|                                                                                                                  
| (vector- 0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|                                                                                                                      
| a4{tv a1Zi} [tv])
|                                                                                                                  
| s3{tv a1Zk} [tv])
|                                                                                                              
| @ (base:GHC.ST.ST{tc rE}
|                                                                                                                  
| s3{tv a1Zk} [tv])
|
| (base:GHC.ST.$fMonadST{v rA} [gid[DFunId]]
|                                                                                                                
| @ s3{tv a1Zk} [tv])
|                                                                                                              
| (dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDV
| ector{v
| rz} [gid[DataConWrapper]]
|                                                                                                                
| @ a4{tv a1Zi} [tv]
|                                                                                                                
| @ s3{tv a1Zk} [tv])
|                                                                                                              
| ((dph-prim-
| par-0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.
| $fDTInt8{v
| ry} [gid]
|                                                                                                                  
| @ s3{tv a1Zk} [tv]
|                                                                                                                  
| g{v a1Zl}
| [lid])
|                                                                                                              
| `cast` (Sym
|
| (base:GHC.ST.NTCo:ST{tc rx}[0]
|
| <s3{tv a1Zk} [tv]>
|
| <dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc
| rD}
|
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|
| s3{tv a1Zk} [tv]>)
|                                                                                                                       ::
| base:GHC.ST.STRep{tc r1j3}
|
| s3{tv a1Zk} [tv]
|
| (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc
| rD}
|
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|
| s3{tv a1Zk} [tv])
|                                                                                                                            
| ~#
|
| base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]
|
| (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc
| rD}
|
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|
| s3{tv a1Zk} [tv])))
|                                                                                                              
| ((\ (s4{v a21s} [lid]
|                                                                                                                    
| :: ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                          
| s3{tv a1Zk} [tv]) ->
|                                                                                                                  
| case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw} [gid]
|                                                                                                                        
| @
| ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                        
| @
| (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                                                                                                                            
| ->
| ghc-prim:GHC.Types.Int{(w) tc 3J})
|                                                                                                                        
| ghc- prim:GHC.Classes.$fOrdInt_$cmax{v rv} [gid]
|                                                                                                                        
| (ghc-
| prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                                                                                                            0)
|                                                                                                                        
| (case g{v a1Zl} [lid]
|                                                                                                                          
| {ghc-
| prim:GHC.Types.Int{(w) tc 3J}}
|                                                                                                                          
| of (wild{v a27g} [lid]
|                                                                                                                                ::
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF})
|                                                                                                                          
| {
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d
| ru} (dt{v a27R} [lid]
|
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
|
| (ds1{v a27S} [lid]
|
| :: [base:GHC.MVar.MVar{tc r1Q2}
|
| dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Req{tc
| r1Q1}])
|
| (ds2{v a27T} [lid]
|
| :: base:GHC.MVar.MVar{tc r1Q2}
|
| ghc-prim:GHC.Types.Bool{(w) tc 3c}) ->
|                                                                                                                          
| ghc-
| prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
|                                                                                                                            
| dt{v a27R} [lid]
|                                                                                                                          })
|                                                                                                                  
| {(# ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                        
| s3{tv a1Zk} [tv],
|                                                                                                                      
| vector- 0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]) #)}
|                                                                                                                  
| of (wild{v a27V} [lid]
|                                                                                                                        
| :: ghc-
| prim:GHC.Types.Int{(w) tc 3J})
|                                                                                                                  
| { ghc-
| prim:GHC.Types.I#{(w) d 6c} (n#{v a280} [lid]
|
| :: ghc-prim:GHC.Prim.Int#{(w) tc 3G}) ->
|                                                                                                                  
| case ghc-
| prim:GHC.Prim.newArray#{(w) v 920} [gid[PrimOp]]
|                                                                                                                        
| @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])
|                                                                                                                        
| @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|                                                                                                                        
| n#{v a280} [lid]
|
| (base:GHC.Err.error{(w) v 05} [gid]
|                                                                                                                            
| @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])
|
| (ghc-prim:GHC.CString.unpackCString#{v 0k} [gid]
|
| "MDist (Vector a) - uninitalised"#))
|                                                                                                                        
| (s4{v a21s} [lid]
|
| `cast` (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (Sym
|
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc
| rs}[0]
|
| <s3{tv a1Zk} [tv]>))
|
| :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| s3{tv a1Zk} [tv]
|
| ~#
|
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))))
|                                                                                                                  
| {(# ghc-
| prim:GHC.Prim.State#{(w) tc 32q}
|                                                                                                                        
| s3{tv a1Zk} [tv],
|                                                                                                                      
| vector- 0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]) #)}
|                                                                                                                  
| of (ds1{v a282} [lid]
|                                                                                                                        
| :: (#
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv])),
|
| ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]) #))
|                                                                                                                  
| { (# (ipv{v a284} [lid]
|                                                                                                                          ::
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))), (ipv1{v a285} [lid]
|
| :: ghc-prim:GHC.Prim.MutableArray#{(w) tc 31m}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])) #) ->
|                                                                                                                  
| (# ipv{v a284} [lid]
|                                                                                                                    
| `cast`
| (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc
| rs}[0]
|
| <s3{tv a1Zk} [tv]>)
|                                                                                                                             ::
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| ~#
|
| ghc-prim:GHC.Prim.State#{(w) tc 32q}
|
| s3{tv a1Zk} [tv]),
|                                                                                                                    
| vector- 0.9.1:Data.Vector.Mutable.MVector{v rr} [gid[DataCon]]
|                                                                                                                      
| @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|                                                                                                                      
| @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv])
|                                                                                                                       0
|                                                                                                                      
| n#{v a280} [lid]
|                                                                                                                      
| ipv1{v a285} [lid] #)
|                                                                                                                  }
|                                                                                                                  })
|                                                                                                              
| `cast` (Sym
|
| (base:GHC.ST.NTCo:ST{tc rx}[0]
|
| <s3{tv a1Zk} [tv]>
|
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (Sym
|
| (primitive-0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc
| rs}[0]
|
| <s3{tv a1Zk} [tv]>))
|
| <vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]>))
|                                                                                                                       ::
| base:GHC.ST.STRep{tc r1j3}
|
| s3{tv a1Zk} [tv]
|
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|
| (base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]))
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]))
|                                                                                                                            
| ~#
|
| base:GHC.ST.ST{tc rE}
|
| s3{tv a1Zk} [tv]
|
| (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|
| s3{tv a1Zk} [tv]
|
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU}
|
| a4{tv a1Zi} [tv]))))
|     Iface expr = \ @ a4
|                    $dUnbox :: vector-0.9.1:Data.Vector.Unboxed.Base.Unbox{tc rW} a4
|                    @ s3
|                    g :: dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{tc rF} ->
|                  base:Control.Monad.liftM2{v rC}
|                    @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                           ghc-prim:GHC.Types.Int{(w) tc 3J} s3)
|                    @ (vector-0.9.1:Data.Vector.Mutable.STVector{tc rB}
|                           s3 (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4))
|                    @ (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                           (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4) s3)
|                    @ (base:GHC.ST.ST{tc rE} s3)
|                    (base:GHC.ST.$fMonadST{v rA} @ s3)
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Vector.$WMDVector{v rz}
|                       @ a4
|                       @ s3)
|                    (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Data.Scalar.Base.$fDTInt8{v ry}
|                       @ s3
|                       g)
|                      `cast`
|                    (Sym (base:GHC.ST.NTCo:ST{tc rx}[0]
|                              (Refl s3)
|                              (Refl
|                                   (dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.DT.MDist{tc rD}
|                                        ghc-prim:GHC.Types.Int{(w) tc 3J} s3))))
|                    (\ s4 :: ghc-prim:GHC.Prim.State#{(w) tc 32q} s3 ->
|                     case vector-0.9.1:Data.Vector.Fusion.Util.delay_inline{v rw}
|                            @ ghc-prim:GHC.Types.Int{(w) tc 3J}
|                            @ (ghc-prim:GHC.Types.Int{(w) tc 3J}
|                               -> ghc-prim:GHC.Types.Int{(w) tc 3J})
|                            ghc-prim:GHC.Classes.$fOrdInt_$cmax{v rv}
|                            (ghc-prim:GHC.Types.I#{(w) v 6d} 0)
|                            (case g of wild { dph-prim-par-
| 0.8.0.1:Data.Array.Parallel.Unlifted.Distributed.Primitive.Gang.Gang{d
| ru} dt
| ds1 ds2 ->
|                             ghc-prim:GHC.Types.I#{(w) v 6d}
|                               dt }) of wild { ghc-prim:GHC.Types.I#{(w) d 6c} n# ->
|                     case ghc-prim:GHC.Prim.newArray#{(w) v 920}
|                            @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                            @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                   (base:GHC.ST.ST{tc rE} s3))
|                            n#
|                            (base:GHC.Err.error{(w) v 05}
|                               @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                               (ghc-prim:GHC.CString.unpackCString#{v 0k}
|                                  "MDist (Vector a) - uninitalised"#))
|                            s4
|                              `cast`
|                            (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                                 (Sym (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                           (Refl
|                                                s3)))) of ds1 {
| ghc-prim:GHC.Prim.(#,#){(w) d 84} ipv ipv1 ->
|                     (# ipv
|                          `cast`
|                        (ghc-prim:GHC.Prim.State#{(w) tc 32q}
|                             (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                  (Refl s3))),
|                        vector-0.9.1:Data.Vector.Mutable.MVector{v rr}
|                          @ (primitive-0.4.0.1:Control.Monad.Primitive.PrimState{tc rt}
|                                 (base:GHC.ST.ST{tc rE} s3))
|                          @ (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc rU} a4)
|                          0
|                          n#
|                          ipv1 #) } })
|                      `cast`
|                    (Sym (base:GHC.ST.NTCo:ST{tc rx}[0]
|                              (Refl s3)
|                              (vector-0.9.1:Data.Vector.Mutable.MVector{tc rq}
|                                   (Sym (primitive-
| 0.4.0.1:Control.Monad.Primitive.TFCo:R:PrimStateST{tc rs}[0]
|                                             (Refl s3)))
|                                   (Refl
| (vector-0.9.1:Data.Vector.Unboxed.Base.Vector{tc
| rU} a4)))))
|
| Please report this as a GHC bug:  
| http://www.haskell.org/ghc/reportabug
|
| make[1]: *** [libraries/dph/dph-prim-par/dist-
| install/build/Data/Array/Parallel/Unlifted/Distributed/Data/USegd/DT.o
| ] Error
| 1
| make: *** [all] Error 2
|
|
| _______________________________________________
| ghc-devs mailing list
| ghc-devs at haskell.org
| http://www.haskell.org/mailman/listinfo/ghc-devs


Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Ian Lynagh-2
On Thu, May 30, 2013 at 09:33:43PM +0000, Simon Peyton-Jones wrote:
> I've pushed a fix.

Thanks, looks good.

The build then failed compiling GHC.TypeLits, so I've reverted

    commit f7fb908ad963f7180c30b55fba57a858b0391de4
    Author: Iavor S. Diatchki <diatchki at Perun.(none)>

which lets the build go through.


Thanks
Ian



Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Iavor Diatchki
Hello,

sorry about this, I forgot to run validate, and I guess the core-lint did
not run in my build.

I have fixed the problem, and this time I remembered to run "validate",
which appears to have mostly worked, except for the 2 problems reported
below.
I don't think that these are related to my change, but I don't really know,
so I am not going to push the fix just yet.  Could you please advice on how
to  investigate further?

-Iavor
PS: Is there some sort of a flag I could set in build.mk so that it always
builds with warnings and core lint?  In some of my GHC trees this seems to
happen, and in others it does not, and for me it'd be quite helpful if it
always did.


Unexpected results from:
TEST="T149 ghcpkg01"

OVERALL SUMMARY for test run started at Thu May 30 19:47:24 PDT 2013
    3657 total tests, which gave rise to
   12141 test cases, of which
    8823 were skipped

      26 had missing libraries
    3233 expected passes
      57 expected failures

       0 caused framework failures
       1 unexpected passes
       1 unexpected failures

Unexpected passes:
   perf/should_run  T149 (normal)

Unexpected failures:
   cabal  ghcpkg01 [bad stderr] (normal)






On Thu, May 30, 2013 at 4:37 PM, Ian Lynagh <ian at well-typed.com> wrote:

> On Thu, May 30, 2013 at 09:33:43PM +0000, Simon Peyton-Jones wrote:
> > I've pushed a fix.
>
> Thanks, looks good.
>
> The build then failed compiling GHC.TypeLits, so I've reverted
>
>     commit f7fb908ad963f7180c30b55fba57a858b0391de4
>     Author: Iavor S. Diatchki <diatchki at Perun.(none)>
>
> which lets the build go through.
>
>
> Thanks
> Ian
>
>
> _______________________________________________
> ghc-devs mailing list
> ghc-devs at haskell.org
> http://www.haskell.org/mailman/listinfo/ghc-devs
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/ghc-devs/attachments/20130530/75b43917/attachment.htm>

Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Simon Peyton Jones
I don?t know about ghcpkg01.  About T149, I?m on a train and can?t check, but I think it?s a common-sub-expression test. It seems to be ?working? now, but CSE is quite fragile (I have an idea for how to improve it, but no time to try it out).

I guess I?ll make it pass, but leave breadcrumbs not to be too surprised if it starts failing agai

Simon

From: Iavor Diatchki [mailto:iavor.diatchki at gmail.com]
Sent: 31 May 2013 03:59
To: Simon Peyton-Jones; ghc-devs at haskell.org
Subject: Re: Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Hello,

sorry about this, I forgot to run validate, and I guess the core-lint did not run in my build.

I have fixed the problem, and this time I remembered to run "validate", which appears to have mostly worked, except for the 2 problems reported below.
I don't think that these are related to my change, but I don't really know, so I am not going to push the fix just yet.  Could you please advice on how to  investigate further?

-Iavor
PS: Is there some sort of a flag I could set in build.mk<http://build.mk> so that it always builds with warnings and core lint?  In some of my GHC trees this seems to happen, and in others it does not, and for me it'd be quite helpful if it always did.


Unexpected results from:
TEST="T149 ghcpkg01"

OVERALL SUMMARY for test run started at Thu May 30 19:47:24 PDT 2013
    3657 total tests, which gave rise to
   12141 test cases, of which
    8823 were skipped

      26 had missing libraries
    3233 expected passes
      57 expected failures

       0 caused framework failures
       1 unexpected passes
       1 unexpected failures

Unexpected passes:
   perf/should_run  T149 (normal)

Unexpected failures:
   cabal  ghcpkg01 [bad stderr] (normal)





On Thu, May 30, 2013 at 4:37 PM, Ian Lynagh <ian at well-typed.com<mailto:ian at well-typed.com>> wrote:
On Thu, May 30, 2013 at 09:33:43PM +0000, Simon Peyton-Jones wrote:
> I've pushed a fix.
Thanks, looks good.

The build then failed compiling GHC.TypeLits, so I've reverted

    commit f7fb908ad963f7180c30b55fba57a858b0391de4
    Author: Iavor S. Diatchki <diatchki at Perun.(none)<mailto:diatchki at Perun.(none)>>

which lets the build go through.


Thanks
Ian


_______________________________________________
ghc-devs mailing list
ghc-devs at haskell.org<mailto:ghc-devs at haskell.org>
http://www.haskell.org/mailman/listinfo/ghc-devs

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/ghc-devs/attachments/20130531/0c4cb966/attachment-0001.htm>

Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Nicolas Frisby
I can't dig up my old email to ghc-devs right now, but I originally
disturbed T149 when I beefed up CorePrep's dead code elimination.

I was greener then and sometimes the test passed, so I held off on changing
the test. But it is evident now that its expected measurements need to be
updated (maybe also making the test more robustly check for CSE).
On May 31, 2013 3:48 AM, "Simon Peyton-Jones" <simonpj at microsoft.com> wrote:

>  I don?t know about ghcpkg01.  About T149, I?m on a train and can?t
> check, but I think it?s a common-sub-expression test. It seems to be
> ?working? now, but CSE is quite fragile (I have an idea for how to improve
> it, but no time to try it out).****
>
> ** **
>
> I guess I?ll make it pass, but leave breadcrumbs not to be too surprised
> if it starts failing agai****
>
> ** **
>
> Simon****
>
> ** **
>
> *From:* Iavor Diatchki [mailto:iavor.diatchki at gmail.com]
> *Sent:* 31 May 2013 03:59
> *To:* Simon Peyton-Jones; ghc-devs at haskell.org
> *Subject:* Re: Validate fails: Var/Type length mismatch: [] [s{tv a15I}
> [tv]]****
>
> ** **
>
> Hello,****
>
> ** **
>
> sorry about this, I forgot to run validate, and I guess the core-lint did
> not run in my build.****
>
> ** **
>
> I have fixed the problem, and this time I remembered to run "validate",
> which appears to have mostly worked, except for the 2 problems reported
> below.****
>
> I don't think that these are related to my change, but I don't really
> know, so I am not going to push the fix just yet.  Could you please advice
> on how to  investigate further?****
>
> ** **
>
> -Iavor****
>
> PS: Is there some sort of a flag I could set in build.mk so that it
> always builds with warnings and core lint?  In some of my GHC trees this
> seems to happen, and in others it does not, and for me it'd be quite
> helpful if it always did.****
>
> ** **
>
> ** **
>
> Unexpected results from:****
>
> TEST="T149 ghcpkg01"****
>
> ** **
>
> OVERALL SUMMARY for test run started at Thu May 30 19:47:24 PDT 2013****
>
>     3657 total tests, which gave rise to****
>
>    12141 test cases, of which****
>
>     8823 were skipped****
>
> ** **
>
>       26 had missing libraries****
>
>     3233 expected passes****
>
>       57 expected failures****
>
> ** **
>
>        0 caused framework failures****
>
>        1 unexpected passes****
>
>        1 unexpected failures****
>
> ** **
>
> Unexpected passes:****
>
>    perf/should_run  T149 (normal)****
>
> ** **
>
> Unexpected failures:****
>
>    cabal  ghcpkg01 [bad stderr] (normal)****
>
> ** **
>
> ** **
>
> ** **
>
> ** **
>
> ** **
>
> On Thu, May 30, 2013 at 4:37 PM, Ian Lynagh <ian at well-typed.com> wrote:***
> *
>
>  On Thu, May 30, 2013 at 09:33:43PM +0000, Simon Peyton-Jones wrote:
> > I've pushed a fix.****
>
> Thanks, looks good.
>
> The build then failed compiling GHC.TypeLits, so I've reverted
>
>     commit f7fb908ad963f7180c30b55fba57a858b0391de4
>     Author: Iavor S. Diatchki <diatchki at Perun.(none)>
>
> which lets the build go through.
>
>
> Thanks
> Ian****
>
>
>
> _______________________________________________
> ghc-devs mailing list
> ghc-devs at haskell.org
> http://www.haskell.org/mailman/listinfo/ghc-devs****
>
>  ** **
>
> _______________________________________________
> ghc-devs mailing list
> ghc-devs at haskell.org
> http://www.haskell.org/mailman/listinfo/ghc-devs
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/ghc-devs/attachments/20130531/e39a47f6/attachment.htm>

Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Ian Lynagh-2
In reply to this post by Iavor Diatchki

Hi Iavor,

On Thu, May 30, 2013 at 07:59:07PM -0700, Iavor Diatchki wrote:
>
> I don't think that these are related to my change, but I don't really know,
> so I am not going to push the fix just yet.  Could you please advice on how
> to  investigate further?

For ghcpkg01, if you have a testlog from a validate run then you can
search for the test in that. Otherwise you can do
    cd testsuite/tests
    make CLEANUP=1 TEST=ghcpkg01 fast
if you were doing a --fast validate, or
    cd testsuite/tests
    make CLEANUP=1 TEST=ghcpkg01 fast BINDIST=YES
for a normal valdiate, and see how it's failing.

> PS: Is there some sort of a flag I could set in build.mk so that it always
> builds with warnings and core lint?  In some of my GHC trees this seems to
> happen, and in others it does not, and for me it'd be quite helpful if it
> always did.

You can see what settings validate uses in mk/validate-settings.mk, and
copy any that you want into mk/build.mk.

In particular, these add lint flags:
    GhcStage2HcOpts += -O -dcore-lint
    GhcLibHcOpts    += -O -dcore-lint


Thanks
Ian
--
Ian Lynagh, Haskell Consultant
Well-Typed LLP, http://www.well-typed.com/


Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Iavor Diatchki
Hello,

OK, I've pushed my change again, please let me know if you notice any more
problems.

The `ghcpkg01` test runs fine if I run it on its own:   make CLEANUP=1
TEST=ghcpkg01 fast

I rerun validate (uinsg: CPUS=8 ./validate) and I got a different cabal
related failure:

 Unexpected failures:
   cabal  shadow [bad stderr] (normal)

Again, it passes when I run it on its own:
make CLEANUP=1 TEST="cabal  shadow" fast

So it seems that there is something that keeps changing... I wonder if it
might be some missing dependency, so when you run things in parallel
sometimes they fail?

-Iavor






On Fri, May 31, 2013 at 8:22 AM, Ian Lynagh <ian at well-typed.com> wrote:

>
> Hi Iavor,
>
> On Thu, May 30, 2013 at 07:59:07PM -0700, Iavor Diatchki wrote:
> >
> > I don't think that these are related to my change, but I don't really
> know,
> > so I am not going to push the fix just yet.  Could you please advice on
> how
> > to  investigate further?
>
> For ghcpkg01, if you have a testlog from a validate run then you can
> search for the test in that. Otherwise you can do
>     cd testsuite/tests
>     make CLEANUP=1 TEST=ghcpkg01 fast
> if you were doing a --fast validate, or
>     cd testsuite/tests
>     make CLEANUP=1 TEST=ghcpkg01 fast BINDIST=YES
> for a normal valdiate, and see how it's failing.
>
> > PS: Is there some sort of a flag I could set in build.mk so that it
> always
> > builds with warnings and core lint?  In some of my GHC trees this seems
> to
> > happen, and in others it does not, and for me it'd be quite helpful if it
> > always did.
>
> You can see what settings validate uses in mk/validate-settings.mk, and
> copy any that you want into mk/build.mk.
>
> In particular, these add lint flags:
>     GhcStage2HcOpts += -O -dcore-lint
>     GhcLibHcOpts    += -O -dcore-lint
>
>
> Thanks
> Ian
> --
> Ian Lynagh, Haskell Consultant
> Well-Typed LLP, http://www.well-typed.com/
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/ghc-devs/attachments/20130531/9090da16/attachment.htm>

Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Ian Lynagh-2
On Fri, May 31, 2013 at 10:14:23AM -0700, Iavor Diatchki wrote:
>
> So it seems that there is something that keeps changing... I wonder if it
> might be some missing dependency, so when you run things in parallel
> sometimes they fail?

There are no dependencies in the testsuite. You're either seeing:
* a bug in a test, which means it is affecting something outside of the test
* a bug in a test, which causes it to inconsistently fail
* some problem with your machine, e.g. dodgy RAM
(from most to least likely).

Note that in the first case it is not necessarily the failing test that
is broken.

The testlog may give more clues as to what is going wrong.


Thanks
Ian
--
Ian Lynagh, Haskell Consultant
Well-Typed LLP, http://www.well-typed.com/


Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Iavor Diatchki
Where would I find the test log?  I just run `validate` without any special
parameters in the root directory of GHC.



On Fri, May 31, 2013 at 10:53 AM, Ian Lynagh <ian at well-typed.com> wrote:

> On Fri, May 31, 2013 at 10:14:23AM -0700, Iavor Diatchki wrote:
> >
> > So it seems that there is something that keeps changing... I wonder if it
> > might be some missing dependency, so when you run things in parallel
> > sometimes they fail?
>
> There are no dependencies in the testsuite. You're either seeing:
> * a bug in a test, which means it is affecting something outside of the
> test
> * a bug in a test, which causes it to inconsistently fail
> * some problem with your machine, e.g. dodgy RAM
> (from most to least likely).
>
> Note that in the first case it is not necessarily the failing test that
> is broken.
>
> The testlog may give more clues as to what is going wrong.
>
>
> Thanks
> Ian
> --
> Ian Lynagh, Haskell Consultant
> Well-Typed LLP, http://www.well-typed.com/
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/ghc-devs/attachments/20130531/7209ff5b/attachment.htm>

Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Ian Lynagh-2
On Fri, May 31, 2013 at 03:28:06PM -0700, Iavor Diatchki wrote:
> Where would I find the test log?  I just run `validate` without any special
> parameters in the root directory of GHC.

It's ./testlog


Thanks
Ian
--
Ian Lynagh, Haskell Consultant
Well-Typed LLP, http://www.well-typed.com/


Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Jan Stolarek
In reply to this post by Ian Lynagh-2
I think that Iavor is facing the same problems that I reported on this list on May 15th. I also
see ghcpkg01 failing (when run during the validation) and passing (when run separately). This
sometimes happens with other tests as well. Iavor, are you getting 'cahce is out of date' error
when the test fails?

Actual stderr output differs from expected:
--- /dev/null???2013-05-14 15:38:10.771000000 +0200
+++ ../../libraries/base/tests/IO/T3307.run.stderr??????2013-05-15 09:21:45.695049002 +0200
@@ -0,0 +1,2 @@
+WARNING: cache is out of date: /dane/uczelnia/projekty/ghc-validate/bindisttest/install ?
dir/lib/ghc-7.7.20130514/package.conf.d/package.cache
+ ?use 'ghc-pkg recache' to fix.
*** unexpected failure for T3307(normal)

I think that these problems are likely to be caused be build artifacts left from previous
validation - package.cache files (and many others) are not removed by `make maintainer-clean`. I
created a patch that fixes this, but it has not been reviewed yet:

http://hackage.haskell.org/trac/ghc/ticket/7941

Perhaps it would resolve these problems.

Janek

> There are no dependencies in the testsuite. You're either seeing:
> * a bug in a test, which means it is affecting something outside of the
> test * a bug in a test, which causes it to inconsistently fail
> * some problem with your machine, e.g. dodgy RAM
> (from most to least likely).
>
> Note that in the first case it is not necessarily the failing test that
> is broken.
>
> The testlog may give more clues as to what is going wrong.
>
>
> Thanks
> Ian




Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Ian Lynagh-2
On Wed, Jun 05, 2013 at 12:17:07PM +0200, Jan Stolarek wrote:
> I think that Iavor is facing the same problems that I reported on this list on May 15th. I also
> see ghcpkg01 failing (when run during the validation) and passing (when run separately).

When you ran it separately, did you say BINDIST=YES ? If you didn't then
it would have used the inplace package.conf.d, not the bindisttest one.

I recently added some "ghc-pkg check -v" calls in the validate script
incidentally, so if you log the output of the validate run then that
might give some more clues as to when/how it goes wrong.

> Actual stderr output differs from expected:
> --- /dev/null???2013-05-14 15:38:10.771000000 +0200
> +++ ../../libraries/base/tests/IO/T3307.run.stderr??????2013-05-15 09:21:45.695049002 +0200
> @@ -0,0 +1,2 @@
> +WARNING: cache is out of date: /dane/uczelnia/projekty/ghc-validate/bindisttest/install ?
> dir/lib/ghc-7.7.20130514/package.conf.d/package.cache
> + ?use 'ghc-pkg recache' to fix.
> *** unexpected failure for T3307(normal)
>
> I think that these problems are likely to be caused be build artifacts left from previous
> validation - package.cache files (and many others) are not removed by `make maintainer-clean`.

test_bindist in bindisttest/ghc.mk removes the entire
    "bindisttest/install   dir"
tree before installing the bindist there.


Thanks
Ian
--
Ian Lynagh, Haskell Consultant
Well-Typed LLP, http://www.well-typed.com/


Reply | Threaded
Open this post in threaded view
|

Validate fails: Var/Type length mismatch: [] [s{tv a15I} [tv]]

Jan Stolarek
> When you ran it separately, did you say BINDIST=YES ? If you didn't then
> it would have used the inplace package.conf.d, not the bindisttest one.
No, I didn't. When I run tests separately I only do 'make TEST=testName'. Should I add BINDIST=YES
when rerunning this test or not?

> I recently added some "ghc-pkg check -v" calls in the validate script
> incidentally, so if you log the output of the validate run then that
> might give some more clues as to when/how it goes wrong.
Great. I'll see what error messages I'm getting whenever this happens again.

> test_bindist in bindisttest/ghc.mk removes the entire
>     "bindisttest/install   dir"
> tree before installing the bindist there.
I noticed that 'make maintainer-clean' doesn't remove "bindisttest/a", but I'm not sure if that is
relevant here. I admit I don't understand structure of this test.

Janek