#include "fusion-phases.h"
module Data.Array.Parallel.PArray.PDataInstances(
PData(..),
pvoid,
punit,
zipPA#, unzipPA#, zip3PA#,
segdPA#, concatPA#, segmentPA#, copySegdPA#
)
where
import Data.Array.Parallel.PArray.Base
import Data.Array.Parallel.PArray.PData
import Data.Array.Parallel.PArray.PRepr
import Data.Array.Parallel.PArray.Types
import Data.Array.Parallel.Lifted.TH.Repr
import Data.Array.Parallel.Lifted.Unboxed (elementsSegd#, elementsSel2_0#, elementsSel2_1#)
import Data.Array.Parallel.Base.DTrace (traceFn)
import Data.Array.Parallel.Base (intToTag)
import qualified Data.Array.Parallel.Unlifted as U
import Data.List (unzip4, unzip5)
import GHC.Exts (Int(..), Int#)
data instance PData Void
pvoid :: PData Void
pvoid = error "Data.Array.Parallel.PData Void"
$(voidPRInstance ''Void 'void 'pvoid)
data instance PData ()
= PUnit
punit :: PData ()
punit = PUnit
$(unitPRInstance 'PUnit)
newtype instance PData (Wrap a)
= PWrap (PData a)
$(wrapPRInstance ''Wrap 'Wrap 'unWrap 'PWrap)
$(tupleInstances [2..5])
zipPA# :: PArray a -> PArray b -> PArray (a ,b)
zipPA# (PArray n# xs) (PArray _ ys)
= PArray n# (P_2 xs ys)
unzipPA# :: PArray (a, b) -> (PArray a, PArray b)
unzipPA# (PArray n# (P_2 xs ys))
= (PArray n# xs, PArray n# ys)
zip3PA# :: PArray a -> PArray b -> PArray c -> PArray (a, b, c)
zip3PA# (PArray n# xs) (PArray _ ys) (PArray _ zs)
= PArray n# (P_3 xs ys zs)
data instance PData (Sum2 a b)
= PSum2 U.Sel2 (PData a) (PData b)
instance (PR a, PR b) => PR (Sum2 a b) where
emptyPR
= traceFn "emptyPR" "(Sum2 a b)" $
PSum2 (U.mkSel2 U.empty U.empty 0 0 (U.mkSelRep2 U.empty)) emptyPR emptyPR
replicatePR n# (Alt2_1 x)
= traceFn "replicatePR" "(Sum2 a b)" $
PSum2 (U.mkSel2 (U.replicate (I# n#) 0)
(U.enumFromStepLen 0 1 (I# n#))
(I# n#) 0
(U.mkSelRep2 (U.replicate (I# n#) 0)))
(replicatePR n# x)
emptyPR
replicatePR n# (Alt2_2 x)
= traceFn "replicatePR" "(Sum2 a b)" $
PSum2 (U.mkSel2 (U.replicate (I# n#) 1)
(U.enumFromStepLen 0 1 (I# n#))
0 (I# n#)
(U.mkSelRep2 (U.replicate (I# n#) 1)))
emptyPR
(replicatePR n# x)
replicatelPR segd (PSum2 sel as bs)
= traceFn "replicatelPR" "(Sum2 a b)" $
PSum2 sel' as' bs'
where
tags = U.tagsSel2 sel
tags' = U.replicate_s segd tags
sel' = U.tagsToSel2 tags'
lens = U.lengthsSegd segd
asegd = U.lengthsToSegd (U.packByTag lens tags 0)
bsegd = U.lengthsToSegd (U.packByTag lens tags 1)
as' = replicatelPR asegd as
bs' = replicatelPR bsegd bs
repeatPR m# n# (PSum2 sel as bs)
= traceFn "repeatPR" "(Sum2 a b)" $
PSum2 sel' as' bs'
where
sel' = U.tagsToSel2
. U.repeat (I# m#) (I# n#)
$ U.tagsSel2 sel
as' = repeatPR m# (elementsSel2_0# sel) as
bs' = repeatPR n# (elementsSel2_1# sel) bs
indexPR (PSum2 sel as bs) i#
= traceFn "indexPR" "(Sum2 a b)" $
case U.indicesSel2 sel U.!: I# i# of
I# k# -> case U.tagsSel2 sel U.!: I# i# of
0 -> Alt2_1 (indexPR as k#)
_ -> Alt2_2 (indexPR bs k#)
appPR (PSum2 sel1 as1 bs1)
(PSum2 sel2 as2 bs2)
= traceFn "appPR" "(Sum2 a b)" $
PSum2 sel (appPR as1 as2)
(appPR bs1 bs2)
where
sel = U.tagsToSel2
$ U.tagsSel2 sel1 U.+:+ U.tagsSel2 sel2
packByTagPR (PSum2 sel as bs) _ tags t#
= PSum2 sel' as' bs'
where
my_tags = U.tagsSel2 sel
my_tags' = U.packByTag my_tags tags (intToTag (I# t#))
sel' = U.tagsToSel2 my_tags'
atags = U.packByTag tags my_tags 0
btags = U.packByTag tags my_tags 1
as' = packByTagPR as (elementsSel2_0# sel') atags t#
bs' = packByTagPR bs (elementsSel2_1# sel') btags t#
combine2PR _ sel (PSum2 sel1 as1 bs1)
(PSum2 sel2 as2 bs2)
= traceFn "combine2PR" "(Sum2 a b)" $
PSum2 sel' as bs
where
tags = U.tagsSel2 sel
tags' = U.combine2 (U.tagsSel2 sel) (U.repSel2 sel)
(U.tagsSel2 sel1)
(U.tagsSel2 sel2)
sel' = U.tagsToSel2 tags'
asel = U.tagsToSel2 (U.packByTag tags tags' 0)
bsel = U.tagsToSel2 (U.packByTag tags tags' 1)
as = combine2PR (elementsSel2_0# sel') asel as1 as2
bs = combine2PR (elementsSel2_1# sel') bsel bs1 bs2
data instance PData (PArray a)
= PNested U.Segd (PData a)
instance PR a => PR (PArray a) where
emptyPR = traceFn "emptyPR" "(PArray a)" $
PNested (U.mkSegd U.empty U.empty 0) emptyPR
replicatePR n# (PArray m# xs)
= traceFn "replicatePR" "(PArray a)" $
PNested (U.mkSegd (U.replicate (I# n#) (I# m#))
(U.enumFromStepLen 0 (I# m#) (I# n#))
(I# n# * I# m#))
(repeatPR n# m# xs)
indexPR (PNested segd xs) i#
= traceFn "indexPR" "(PArray a)" $
case U.lengthsSegd segd U.!: I# i# of { I# n# ->
case U.indicesSegd segd U.!: I# i# of { I# k# ->
PArray n# (extractPR xs k# n#) }}
extractPR (PNested segd xs) i# n#
= traceFn "extractPR" "(PArray a)" $
PNested segd' (extractPR xs k# (elementsSegd# segd'))
where
segd' = U.lengthsToSegd
$ U.extract (U.lengthsSegd segd) (I# i#) (I# n#)
!(I# k#) | I# i# == 0 = 0
| otherwise = U.indicesSegd segd U.!: (I# i# 1)
+ U.lengthsSegd segd U.!: (I# i# 1)
bpermutePR (PNested segd xs) _ is
= traceFn "bpermutePR" "(PArray a)" $
PNested segd' (bpermutePR xs (elementsSegd# segd') js)
where
lens' = U.bpermute (U.lengthsSegd segd) is
starts = U.bpermute (U.indicesSegd segd) is
segd' = U.lengthsToSegd lens'
js = U.zipWith (+) (U.indices_s segd')
(U.replicate_s segd' starts)
appPR (PNested xsegd xs) (PNested ysegd ys)
= traceFn "appPR" "(PArray a)" $
PNested (U.lengthsToSegd (U.lengthsSegd xsegd U.+:+ U.lengthsSegd ysegd))
(appPR xs ys)
applPR rsegd segd1 (PNested xsegd xs) segd2 (PNested ysegd ys)
= traceFn "applPR" "(PArray a)"$
PNested segd (applPR (U.plusSegd xsegd' ysegd') xsegd' xs ysegd' ys)
where
segd = U.lengthsToSegd
$ U.append_s rsegd segd1 (U.lengthsSegd xsegd)
segd2 (U.lengthsSegd ysegd)
xsegd' = U.lengthsToSegd
$ U.sum_s segd1 (U.lengthsSegd xsegd)
ysegd' = U.lengthsToSegd
$ U.sum_s segd2 (U.lengthsSegd ysegd)
repeatPR n# len# (PNested segd xs)
= traceFn "repeatPR" "(PArray a)" $
PNested segd' (repeatPR n# (elementsSegd# segd) xs)
where
segd' = U.lengthsToSegd (U.repeat (I# n#) (I# len#) (U.lengthsSegd segd))
replicatelPR segd (PNested xsegd xs)
= traceFn "replicatelPR" "(PArray a)" $
PNested xsegd' $ bpermutePR xs (elementsSegd# xsegd')
$ U.enumFromStepLenEach (U.elementsSegd xsegd')
is (U.replicate (U.elementsSegd segd) 1) ns
where
is = U.replicate_s segd (U.indicesSegd xsegd)
ns = U.replicate_s segd (U.lengthsSegd xsegd)
xsegd' = U.lengthsToSegd ns
packByTagPR (PNested segd xs) _ tags t#
= traceFn "packByTagPR" "(PArray a)" $
PNested segd' xs'
where
segd' = U.lengthsToSegd
$ U.packByTag (U.lengthsSegd segd) tags (intToTag (I# t#))
xs' = packByTagPR xs (elementsSegd# segd') (U.replicate_s segd tags) t#
combine2PR _ sel (PNested xsegd xs) (PNested ysegd ys)
= traceFn "combine2PR" "(PArray a)" $
PNested segd xys
where
tags = U.tagsSel2 sel
segd = U.lengthsToSegd
$ U.combine2 (U.tagsSel2 sel) (U.repSel2 sel)
(U.lengthsSegd xsegd)
(U.lengthsSegd ysegd)
sel' = U.tagsToSel2
$ U.replicate_s segd tags
xys = combine2PR (elementsSegd# segd) sel' xs ys
segdPA# :: PArray (PArray a) -> U.Segd
segdPA# (PArray _ (PNested segd _))
= segd
concatPA# :: PArray (PArray a) -> PArray a
concatPA# (PArray _ (PNested segd xs))
= PArray (elementsSegd# segd) xs
segmentPA# :: Int# -> U.Segd -> PArray a -> PArray (PArray a)
segmentPA# n# segd (PArray _ xs)
= PArray n# (PNested segd xs)
copySegdPA# :: PArray (PArray a) -> PArray b -> PArray (PArray b)
copySegdPA# (PArray n# (PNested segd _)) (PArray _ xs)
= PArray n# (PNested segd xs)