module Futhark.CodeGen.Backends.SequentialPython
( compileProg,
)
where
import Control.Monad
import Data.Text qualified as T
import Futhark.CodeGen.Backends.GenericPython qualified as GenericPython
import Futhark.CodeGen.Backends.GenericPython.AST
import Futhark.CodeGen.ImpCode.Sequential qualified as Imp
import Futhark.CodeGen.ImpGen.Sequential qualified as ImpGen
import Futhark.IR.SeqMem
import Futhark.MonadFreshNames
compileProg ::
MonadFreshNames m =>
GenericPython.CompilerMode ->
String ->
Prog SeqMem ->
m (ImpGen.Warnings, T.Text)
compileProg :: forall (m :: * -> *).
MonadFreshNames m =>
CompilerMode -> [Char] -> Prog SeqMem -> m (Warnings, Text)
compileProg CompilerMode
mode [Char]
class_name =
forall (m :: * -> *).
MonadFreshNames m =>
Prog SeqMem -> m (Warnings, Program)
ImpGen.compileProg
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
( forall (m :: * -> *) op s.
MonadFreshNames m =>
CompilerMode
-> [Char]
-> Constructor
-> [PyStmt]
-> [PyStmt]
-> Operations op s
-> s
-> [PyStmt]
-> [Option]
-> Definitions op
-> m Text
GenericPython.compileProg
CompilerMode
mode
[Char]
class_name
Constructor
GenericPython.emptyConstructor
[PyStmt]
imports
forall {a}. [a]
defines
Operations Sequential ()
operations
()
[]
[]
)
where
imports :: [PyStmt]
imports =
[ [Char] -> Maybe [Char] -> PyStmt
Import [Char]
"sys" forall a. Maybe a
Nothing,
[Char] -> Maybe [Char] -> PyStmt
Import [Char]
"numpy" forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just [Char]
"np",
[Char] -> Maybe [Char] -> PyStmt
Import [Char]
"ctypes" forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just [Char]
"ct",
[Char] -> Maybe [Char] -> PyStmt
Import [Char]
"time" forall a. Maybe a
Nothing
]
defines :: [a]
defines = []
operations :: GenericPython.Operations Imp.Sequential ()
operations :: Operations Sequential ()
operations =
forall op s. Operations op s
GenericPython.defaultOperations
{ opsCompiler :: OpCompiler Sequential ()
GenericPython.opsCompiler = forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Applicative f => a -> f a
pure (),
opsCopy :: Copy Sequential ()
GenericPython.opsCopy = Copy Sequential ()
copySequentialMemory
}
copySequentialMemory :: GenericPython.Copy Imp.Sequential ()
copySequentialMemory :: Copy Sequential ()
copySequentialMemory PyExp
destmem PyExp
destidx Space
DefaultSpace PyExp
srcmem PyExp
srcidx Space
DefaultSpace PyExp
nbytes PrimType
_bt =
forall op s.
PyExp -> PyExp -> PyExp -> PyExp -> PyExp -> CompilerM op s ()
GenericPython.copyMemoryDefaultSpace PyExp
destmem PyExp
destidx PyExp
srcmem PyExp
srcidx PyExp
nbytes
copySequentialMemory PyExp
_ PyExp
_ Space
destspace PyExp
_ PyExp
_ Space
srcspace PyExp
_ PrimType
_ =
forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Cannot copy to " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Space
destspace forall a. [a] -> [a] -> [a]
++ [Char]
" from " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Space
srcspace