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

SCM Repository

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

Diff of /branches/vis12/src/compiler/cl-target/cl-target.sml

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

revision 1852, Tue Apr 17 13:15:51 2012 UTC revision 1853, Tue Apr 17 13:16:21 2012 UTC
# Line 12  Line 12 
12      structure Ty = IL.Ty      structure Ty = IL.Ty
13      structure CL = CLang      structure CL = CLang
14      structure RN = RuntimeNames      structure RN = RuntimeNames
     structure ToCL = TreeToCL  
15      structure N = CNames      structure N = CNames
16        structure ToCL = TreeToCL
17      structure P = Paths      structure P = Paths
18      structure HF = CLHeaderFrag      structure HF = CLHeaderFrag
19      structure SF = CLSchedFrag      structure SF = CLSchedFrag
# Line 88  Line 88 
88            (* end case *))            (* end case *))
89    
90    (* helper functions for specifying parameters in various address spaces *)    (* helper functions for specifying parameters in various address spaces *)
91      fun clParam (spc, ty, x) = CL.PARAM([spc], ty, x)      fun clParam spc (ty, x) = CL.PARAM([spc], ty, x)
92      fun globalParam (ty, x) = CL.PARAM(["__global"], ty, x)      val globalParam = clParam "__global"
93      fun constantParam (ty, x) = CL.PARAM(["__constant"], ty, x)      val constantParam = clParam "__constant"
94      fun localParam (ty, x) = CL.PARAM(["__local"], ty, x)      val localParam = clParam "__local"
95      fun privateParam (ty, x) = CL.PARAM(["__private"], ty, x)      val privateParam = clParam "__private"
96    
97    (* OpenCL global pointer type *)    (* OpenCL global pointer type *)
98      fun globalPtr ty = CL.T_Qual("__global", CL.T_Ptr ty)      fun globalPtr ty = CL.T_Qual("__global", CL.T_Ptr ty)
# Line 275  Line 275 
275                }                }
276        end        end
277    
278    
279      (* strands *)
280        structure Strand =
281          struct
282    
283            fun define (Prog{strands, ...}, strandId, state) = let
284                  val name = Atom.toString strandId
285                (* the output state variable *)
286                  val outputVar = (case List.filter IL.StateVar.isOutput state
287                         of [] => raise Fail("no output specified for strand " ^ name)
288                          | [x] => (IL.StateVar.ty x, IL.StateVar.name x)
289                          | _ => raise Fail("multiple outputs in " ^ name)
290                        (* end case *))
291                (* the state variables *)
292                  val state = let
293                        fun cvt x = Var.mirror (IL.StateVar.ty x, IL.StateVar.name x, STRAND_SHADOW)
294                        in
295                          List.map cvt state
296                        end
297                  val strand = Strand{
298                          name = name,
299                          tyName = RN.strandTy name,
300                          state = state,
301                          output = outputVar,
302                          code = ref [],
303                          init_code = ref (CL.D_Comment(["no init code"]))
304                        }
305                  in
306                    AtomTable.insert strands (strandId, strand);
307                    strand
308                  end
309    
310          (* return the strand with the given name *)
311            fun lookup (Prog{strands, ...}, strandId) = AtomTable.lookup strands strandId
312    
313          (* register the strand-state initialization code.  The variables are the strand
314           * parameters.
315           *)
316            fun init (Strand{name, tyName, code, init_code, ...}, params, init) = let
317                  val fName = RN.strandInit name
318                  val params =
319                        clParam "" (CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
320                          List.map (fn (ToCL.V(ty, x)) => CL.PARAM([], ty, x)) params
321                  val initFn = CL.D_Func([], CL.voidTy, fName, params, init)
322                  in
323                    init_code := initFn
324                  end
325    
326          (* register a strand method *)
327            fun method (Strand{name, tyName, code,...}, methName, body) = let
328                  val params = [
329                          globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),
330                          globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),
331                          globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName),
332                          clParam "" (CL.T_Named(RN.imageDataType), RN.globalImageDataName)
333                        ]
334                  val (fName,resTy) = (case methName
335                         of StrandUtil.Update => (RN.strandUpdate,CL.T_Named "StrandStatus_t")
336                          | StrandUtil.Stabilize => (name ^ StrandUtil.nameToString methName, CL.voidTy)
337                        (* end case *))
338                  val methFn = CL.D_Func([], resTy, fName, params, body)
339                  in
340                    code := methFn :: !code
341                  end
342    
343          end (* Strand *)
344    
345    (* programs *)    (* programs *)
346      structure Program =      structure Program =
347        struct        struct
# Line 801  Line 868 
868    
869        end (* Program *)        end (* Program *)
870    
   (* strands *)  
     structure Strand =  
       struct  
   
         fun define (Prog{strands, ...}, strandId, state) = let  
               val name = Atom.toString strandId  
             (* the output state variable *)  
               val outputVar = (case List.filter IL.StateVar.isOutput state  
                      of [] => raise Fail("no output specified for strand " ^ name)  
                       | [x] => (IL.StateVar.ty x, IL.StateVar.name x)  
                       | _ => raise Fail("multiple outputs in " ^ name)  
                     (* end case *))  
             (* the state variables *)  
               val state = let  
                     fun cvt x = Var.mirror (IL.StateVar.ty x, IL.StateVar.name x, STRAND_SHADOW)  
                     in  
                       List.map cvt state  
                     end  
               val strand = Strand{  
                       name = name,  
                       tyName = RN.strandTy name,  
                       state = state,  
                       output = outputVar,  
                       code = ref [],  
                       init_code = ref (CL.D_Comment(["no init code"]))  
                     }  
               in  
                 AtomTable.insert strands (strandId, strand);  
                 strand  
               end  
   
       (* return the strand with the given name *)  
         fun lookup (Prog{strands, ...}, strandId) = AtomTable.lookup strands strandId  
   
       (* register the strand-state initialization code.  The variables are the strand  
        * parameters.  
        *)  
         fun init (Strand{name, tyName, code, init_code, ...}, params, init) = let  
               val fName = RN.strandInit name  
               val params =  
                     clParam ("",CL.T_Ptr(CL.T_Named tyName), "selfOut") ::  
                       List.map (fn (ToCL.V(ty, x)) => CL.PARAM([], ty, x)) params  
               val initFn = CL.D_Func([], CL.voidTy, fName, params, init)  
               in  
                 init_code := initFn  
               end  
   
       (* register a strand method *)  
         fun method (Strand{name, tyName, code,...}, methName, body) = let  
               val params = [  
                       globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),  
                       globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),  
                       globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName),  
                       CL.PARAM([],CL.T_Named(RN.imageDataType),RN.globalImageDataName)  
                     ]  
               val (fName,resTy) = (case methName  
                      of StrandUtil.Update => (RN.strandUpdate,CL.T_Named "StrandStatus_t")  
                       | StrandUtil.Stabilize => (name ^ StrandUtil.nameToString methName, CL.voidTy)  
                     (* end case *))  
               val methFn = CL.D_Func([], resTy, fName, params, body)  
               in  
                 code := methFn :: !code  
               end  
   
       end  
   
871    end    end
872    
873  structure CLBackEnd = CodeGenFn(CLTarget)  structure CLBackEnd = CodeGenFn(CLTarget)

Legend:
Removed from v.1852  
changed lines
  Added in v.1853

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