Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /branches/pure-cfg/src/compiler/cl-target/cl-target.sml
ViewVC logotype

Diff of /branches/pure-cfg/src/compiler/cl-target/cl-target.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1278, Mon Jun 6 16:27:28 2011 UTC revision 1286, Tue Jun 7 10:54:18 2011 UTC
# Line 14  Line 14 
14      structure RN = RuntimeNames      structure RN = RuntimeNames
15      structure ToCL = TreeToCL      structure ToCL = TreeToCL
16    
17      type var = ToCL.var    (* C variable translation *)
18        structure TrCVar =
19          struct
20            type env = CL.typed_var TreeIL.Var.Map.map
21            fun lookup (env, x) = (case V.Map.find (env, x)
22                   of SOME(CL.V(_, x')) => x'
23                    | NONE => raise Fail(concat["TrCVar.lookup(_, ", V.name x, ")"])
24                  (* end case *))
25          (* translate a variable that occurs in an l-value context (i.e., as the target of an assignment) *)
26            fun lvalueVar (env, x) = (case V.kind x
27                   of IL.VK_Global => CL.mkIndirect(CL.mkVar RN.globalsVarName, lookup(env, x))
28                    | IL.VK_State strand => raise Fail "unexpected strand context"
29                    | IL.VK_Local => CL.mkVar(lookup(env, x))
30                  (* end case *))
31          (* translate a variable that occurs in an r-value context *)
32            val rvalueVar = lvalueVar
33          end
34    
35        structure ToC = TreeToCFn (TrCVar)
36    
37        type var = CL.typed_var
38      type exp = CL.exp      type exp = CL.exp
39      type stm = CL.stm      type stm = CL.stm
40    
41      (* OpenCL specific types *)
42        val clProgramTy = CL.T_Named "cl_program"
43        val clKernelTy  = CL.T_Named "cl_kernel"
44        val clCmdQueueTy = CL.T_Named "cl_command_queue"
45        val clContextTy = CL.T_Named "cl_context"
46        val clDeviceIdTy = CL.T_Named "cl_device_id"
47        val clPlatformIdTy = CL.T_Named "cl_platform_id"
48        val clMemoryTy = CL.T_Named "cl_mem"
49    
50      datatype strand = Strand of {      datatype strand = Strand of {
51          name : string,          name : string,
52          tyName : string,          tyName : string,
# Line 69  Line 98 
98    (* TreeIL to target translations *)    (* TreeIL to target translations *)
99      structure Tr =      structure Tr =
100        struct        struct
101          (* this function is used for the initially clause, so it generates OpenCL *)
102          fun fragment (ENV{info, vMap, scope}, blk) = let          fun fragment (ENV{info, vMap, scope}, blk) = let
103                val (vMap, stms) = ToCL.trFragment (vMap, blk)                val (vMap, stms) = ToCL.trFragment (vMap, blk)
104                in                in
# Line 85  Line 115 
115          fun block (ENV{vMap, scope, ...}, blk) = (case scope          fun block (ENV{vMap, scope, ...}, blk) = (case scope
116                 of StrandScope stateVars => ToCL.trBlock (vMap, saveState "StrandScope" stateVars, blk)                 of StrandScope stateVars => ToCL.trBlock (vMap, saveState "StrandScope" stateVars, blk)
117                  | MethodScope stateVars => ToCL.trBlock (vMap, saveState "MethodScope" stateVars, blk)                  | MethodScope stateVars => ToCL.trBlock (vMap, saveState "MethodScope" stateVars, blk)
118                  | _ => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)                  | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)
119                    | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)
120                (* end case *))                (* end case *))
121          fun exp (ENV{vMap, ...}, e) = ToCL.trExp(vMap, e)          fun exp (ENV{vMap, ...}, e) = ToCL.trExp(vMap, e)
122        end        end
# Line 141  Line 172 
172        struct        struct
173          fun new {name, double, parallel, debug} = (          fun new {name, double, parallel, debug} = (
174                RN.initTargetSpec double;                RN.initTargetSpec double;
175                  CNames.initTargetSpec double;
176                Prog{                Prog{
177                    name = name,                    name = name,
178                    double = double, parallel = parallel, debug = debug,                    double = double, parallel = parallel, debug = debug,
# Line 154  Line 186 
186                  })                  })
187        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
188            fun globalIndirects (globals,stms) = let            fun globalIndirects (globals,stms) = let
189                  fun getGlobals(CL.D_Var(_,_,globalVar,_)::rest) = CL.mkAssign(CL.mkIndirect(CL.mkVar RN.globalsVarName,globalVar),CL.mkVar globalVar)::getGlobals(rest)                  fun getGlobals (CL.D_Var(_,_,globalVar,_)::rest) =
190                    | getGlobals([]) = []                        CL.mkAssign(CL.mkIndirect(CL.mkVar RN.globalsVarName,globalVar),CL.mkVar globalVar)
191                    | getGlobals(_::rest) = getGlobals(rest)                          ::getGlobals rest
192                      | getGlobals [] = []
193                      | getGlobals (_::rest) = getGlobals rest
194                  in                  in
195                    stms @ getGlobals(globals)                    stms @ getGlobals globals
196                  end                  end
197    
198        (* register the code that is used to register command-line options for input variables *)        (* register the code that is used to register command-line options for input variables *)
# Line 171  Line 205 
205                  topDecls := inputsFn :: !topDecls                  topDecls := inputsFn :: !topDecls
206                end                end
207    
208          fun init (Prog{globals, topDecls,...}, CL.S_Block(init)) = let        (* register the global initialization part of a program *)
209                val params = [          fun init (Prog{topDecls, ...}, init) = let
210                        CL.PARAM([], CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName)                val globPtrTy = CL.T_Ptr(CL.T_Named RN.globalsTy)
211                      ]                val initFn = CL.D_Func(
212                val body = CL.S_Block(globalIndirects(!globals,init))                      [], CL.voidTy, RN.initGlobals, [CL.PARAM([], globPtrTy, RN.globalsVarName)],
213                val initFn = CL.D_Func([], CL.voidTy, RN.initGlobals, params, body)                      init)
214                in                val shutdownFn = CL.D_Func(
215                  topDecls := initFn :: !topDecls                      [], CL.voidTy, RN.shutdown,
216                end                      [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.worldTy), "wrld")],
217            | init (Prog{globals,topDecls,...}, init) = let                      CL.S_Block[])
               val params = [  
                       CL.PARAM([], CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName)  
                     ]  
               val initFn = CL.D_Func([], CL.voidTy, RN.initGlobals, params, init)  
218                in                in
219                  topDecls := initFn :: !topDecls                  topDecls := shutdownFn :: initFn :: !topDecls
220                end                end
221    
222        (* create and register the initially function for a program *)        (* create and register the initially function for a program *)
# Line 219  Line 249 
249                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "size", SOME(CL.I_Array sizeInit)),                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "size", SOME(CL.I_Array sizeInit)),
250                        CL.mkDecl(CL.int32,"numDims",SOME(CL.I_Exp(CL.mkInt(IntInf.fromInt nDims, CL.int32))))                        CL.mkDecl(CL.int32,"numDims",SOME(CL.I_Exp(CL.mkInt(IntInf.fromInt nDims, CL.int32))))
251                      ]                      ]
252                val numStrandsLoopBody = CL.mkExpStm(CL.mkAssignOp(CL.mkVar numStrandsVar, CL.*=,CL.mkSubscript(CL.mkVar "size",CL.mkVar "i")))                val numStrandsLoopBody =
253                        CL.mkExpStm(CL.mkAssignOp(CL.mkVar numStrandsVar, CL.*=,CL.mkSubscript(CL.mkVar "size",CL.mkVar "i")))
254                val numStrandsLoop =  CL.mkFor([(CL.intTy, "i", CL.mkInt(0,CL.intTy))],                val numStrandsLoop =  CL.mkFor([(CL.intTy, "i", CL.mkInt(0,CL.intTy))],
255                      CL.mkBinOp(CL.mkVar "i", CL.#<, CL.mkVar "numDims"),                      CL.mkBinOp(CL.mkVar "i", CL.#<, CL.mkVar "numDims"),
256                      [CL.mkPostOp(CL.mkVar "i", CL.^++)], numStrandsLoopBody)                      [CL.mkPostOp(CL.mkVar "i", CL.^++)], numStrandsLoopBody)
# Line 253  Line 284 
284                                                  CL.mkBlock([CL.mkCall(RN.strandInit name, [CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "strands",index)),                                                  CL.mkBlock([CL.mkCall(RN.strandInit name, [CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "strands",index)),
285                                                  CL.mkVar "x", CL.mkVar"y"])])                                                  CL.mkVar "x", CL.mkVar"y"])])
286                                          end                                          end
   
287                                  | mkLoopNest (param::rest,count,nDims) = let                                  | mkLoopNest (param::rest,count,nDims) = let
288                                          val body = mkLoopNest (rest, count + 1,nDims)                                          val body = mkLoopNest (rest, count + 1,nDims)
289                                     in                                     in
# Line 269  Line 299 
299                  in                  in
300                          CL.D_Func(["static"], CL.voidTy, RN.strandInitSetup, params,CL.mkBlock(body))                          CL.D_Func(["static"], CL.voidTy, RN.strandInitSetup, params,CL.mkBlock(body))
301                  end                  end
302    
303          fun genStrandPrint (Strand{name, tyName, state, output, code,...},nDims) = let          fun genStrandPrint (Strand{name, tyName, state, output, code,...},nDims) = let
304              (* the print function *)              (* the print function *)
305                val prFnName = concat[name, "_print"]                val prFnName = concat[name, "_print"]
   
306                val prFn = let                val prFn = let
307                      val params = [                      val params = [
308                            CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),                            CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),
# Line 370  Line 400 
400                                                  "}"])                                                  "}"])
401  (* generates the opencl buffers for the image data *)  (* generates the opencl buffers for the image data *)
402          fun getGlobalDataBuffers(globals,count,contextVar,errVar) = let          fun getGlobalDataBuffers(globals,count,contextVar,errVar) = let
403                  val globalBufferDecl =  CL.mkDecl(CL.clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)                  val globalBufferDecl =  CL.mkDecl(clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)
404                  val globalBuffer = CL.mkAssign(CL.mkVar(concat[RN.globalsVarName,"_cl"]), CL.mkApply("clCreateBuffer",                  val globalBuffer = CL.mkAssign(CL.mkVar(concat[RN.globalsVarName,"_cl"]), CL.mkApply("clCreateBuffer",
405                                                                  [CL.mkVar contextVar,                                                                  [CL.mkVar contextVar,
406                                                                  CL.mkVar "CL_MEM_COPY_HOST_PTR",                                                                  CL.mkVar "CL_MEM_COPY_HOST_PTR",
# Line 392  Line 422 
422                                            CL.mkIndirect(CL.mkVar var,concat["size[0]", " * ", var, "->size[1] * ", var, "->size[2]"]))                                            CL.mkIndirect(CL.mkVar var,concat["size[0]", " * ", var, "->size[1] * ", var, "->size[2]"]))
423    
424                   in                   in
425                     CL.mkDecl(CL.clMemoryTy,RN.addBufferSuffix var ,NONE)::                     CL.mkDecl(clMemoryTy, RN.addBufferSuffix var ,NONE)::
426                     CL.mkDecl(CL.clMemoryTy,RN.addBufferSuffixData var ,NONE)::                     CL.mkDecl(clMemoryTy, RN.addBufferSuffixData var ,NONE)::
427                     CL.mkAssign(CL.mkVar(RN.addBufferSuffix var), CL.mkApply("clCreateBuffer",                     CL.mkAssign(CL.mkVar(RN.addBufferSuffix var), CL.mkApply("clCreateBuffer",
428                                                                  [CL.mkVar contextVar,                                                                  [CL.mkVar contextVar,
429                                                                  CL.mkVar "CL_MEM_COPY_HOST_PTR",                                                                  CL.mkVar "CL_MEM_COPY_HOST_PTR",
# Line 489  Line 519 
519                        CL.PARAM([],CL.T_Named("cl_device_id"), deviceVar)                        CL.PARAM([],CL.T_Named("cl_device_id"), deviceVar)
520                      ]                      ]
521                val declarations = [                val declarations = [
522                      CL.mkDecl(CL.clProgramTy, programVar, NONE),                      CL.mkDecl(clProgramTy, programVar, NONE),
523                      CL.mkDecl(CL.clKernelTy, kernelVar, NONE),                      CL.mkDecl(clKernelTy, kernelVar, NONE),
524                      CL.mkDecl(CL.clCmdQueueTy, cmdVar, NONE),                      CL.mkDecl(clCmdQueueTy, cmdVar, NONE),
525                      CL.mkDecl(CL.clContextTy, contextVar, NONE),                      CL.mkDecl(clContextTy, contextVar, NONE),
526                      CL.mkDecl(CL.intTy, errVar, NONE),                      CL.mkDecl(CL.intTy, errVar, NONE),
527                      CL.mkDecl(CL.intTy, numStrandsVar, SOME(CL.I_Exp(CL.mkInt(1,CL.intTy)))),                      CL.mkDecl(CL.intTy, numStrandsVar, SOME(CL.I_Exp(CL.mkInt(1,CL.intTy)))),
528                      CL.mkDecl(CL.intTy, stateSizeVar, NONE),                      CL.mkDecl(CL.intTy, stateSizeVar, NONE),
529                      CL.mkDecl(CL.intTy, "width", NONE),                      CL.mkDecl(CL.intTy, "width", NONE),
530                      CL.mkDecl(CL.intTy, imgDataSizeVar, NONE),                      CL.mkDecl(CL.intTy, imgDataSizeVar, NONE),
531                      (*CL.mkDecl(CL.clDeviceIdTy, deviceVar, NONE), *)                      (*CL.mkDecl(clDeviceIdTy, deviceVar, NONE), *)
532                      CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), inStateVar,NONE),                      CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), inStateVar,NONE),
533                      CL.mkDecl(CL.clMemoryTy,clInstateVar,NONE),                      CL.mkDecl(clMemoryTy,clInstateVar,NONE),
534                      CL.mkDecl(CL.clMemoryTy,clOutStateVar,NONE),                      CL.mkDecl(clMemoryTy,clOutStateVar,NONE),
535                      CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), outStateVar,NONE),                      CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), outStateVar,NONE),
536                      CL.mkDecl(CL.charPtr, clFNVar,SOME(CL.I_Exp(CL.mkStr filename))),                      CL.mkDecl(CL.charPtr, clFNVar,SOME(CL.I_Exp(CL.mkStr filename))),
537  (* FIXME:  use Paths.diderotInclude *)  (* FIXME:  use Paths.diderotInclude *)
# Line 900  Line 930 
930                val clppStrm = PrintAsC.new clOutS                val clppStrm = PrintAsC.new clOutS
931                val cppStrm = PrintAsC.new cOutS                val cppStrm = PrintAsC.new cOutS
932                fun cppDecl dcl = PrintAsC.output(cppStrm, dcl)                fun cppDecl dcl = PrintAsC.output(cppStrm, dcl)
933                fun clppDecl dcl = PrintAsC.output(clppStrm, dcl)                fun clppDecl dcl = PrintAsCL.output(clppStrm, dcl)
934                val strands = AtomTable.listItems strands                val strands = AtomTable.listItems strands
935                val [strand as Strand{name, tyName, code,init_code, ...}] = strands                val [strand as Strand{name, tyName, code,init_code, ...}] = strands
936                in                in
# Line 935  Line 965 
965                  List.app cppDecl (List.rev (!topDecls));                  List.app cppDecl (List.rev (!topDecls));
966                  cppDecl (genHostSetupFunc (strand, clFileName, !numDims, initially, imgGlobals));                  cppDecl (genHostSetupFunc (strand, clFileName, !numDims, initially, imgGlobals));
967                  PrintAsC.close cppStrm;                  PrintAsC.close cppStrm;
968                  PrintAsC.close clppStrm;                  PrintAsCL.close clppStrm;
969                  TextIO.closeOut cOutS;                  TextIO.closeOut cOutS;
970                  TextIO.closeOut clOutS                  TextIO.closeOut clOutS
971                end                end

Legend:
Removed from v.1278  
changed lines
  Added in v.1286

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0