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

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/target-cpu/gen-inputs.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/target-cpu/gen-inputs.sml

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

revision 3909, Tue May 24 21:20:42 2016 UTC revision 3910, Tue May 24 21:55:24 2016 UTC
# Line 31  Line 31 
31    (*** Support for libraries ***)    (*** Support for libraries ***)
32    
33    (* generate the typedef for the defined-input flag struct. *)    (* generate the typedef for the defined-input flag struct. *)
34      val genDefinedInpStruct : Properties.props * input_desc list -> CLang.decl list      val genDefinedInpStruct : CodeGenEnv.t * input_desc list -> CLang.decl list
35    
36    (* generated the functions to initialize inputs for the library API.  This function also    (* generated the functions to initialize inputs for the library API.  This function also
37     * generates the function to initialize the defined input flags struct.     * generates the function to initialize the defined input flags struct.
38     *)     *)
39      val genInputFuns : Properties.props * input_desc list -> CLang.decl list      val genInputFuns : CodeGenEnv.t * input_desc list -> CLang.decl list
40    
41    end = struct    end = struct
42    
43      structure IR = TreeIR      structure IR = TreeIR
44      structure Ty = TreeIR.Ty      structure Ty = TreeIR.Ty
45      structure GVar = IR.GlobalVar      structure GVar = TreeGlobalVar
46      structure CL = CLang      structure CL = CLang
47      structure N = CNames      structure RN = CxxNames
48      structure ToC = TreeToC      structure ToC = TreeToCxx
49      structure TrTy = CTyTranslate      structure TrTy = CTyTranslate
50      structure U = GenInputsUtil      structure U = GenInputsUtil
51        structure Env = CodeGenEnv
52    
53      type input_desc = U.input_desc      type input_desc = U.input_desc
54    
55      val genInputsStruct = U.genInputsStruct      val genInputsStruct = U.genInputsStruct
56      val genDefinedInpStruct = U.genDefinedInpStruct      val genDefinedInpStruct = U.genDefinedInpStruct
57    
58    (* translate a TreeIR type to the C types used to represent it in the external API *)    (* translate an API type to the C types used to represent it in the external API *)
59      val trType = TrTy.toCType      val trType = CodeGenUtil.trAPIType
60    
61      val nrrdPtrTy = CL.T_Ptr(CL.T_Named "Nrrd")      val nrrdPtrTy = CL.T_Ptr(CL.T_Named "Nrrd")
     val wrldPrefixTy = CL.T_Ptr(CL.T_Named "WorldPrefix_t")  
62    
63    (* world pointer cast to the world prefix type *)    (* world pointer *)
64      val wrldPrefix = CL.mkCast(wrldPrefixTy, CL.mkVar "wrld")      val wrldV = CL.mkVar "wrld"
65    
66    (* an l-value expression for accessing a global variable *)    (* an l-value expression for accessing a global variable *)
67      fun global gv = CL.mkIndirect(CL.mkIndirect(CL.mkVar "wrld", "globals"), GVar.name gv)      fun global gv = CL.mkIndirect(CL.mkIndirect(CL.mkVar "wrld", "globals"), GVar.name gv)
68    
69    (* generate code to initialize the global input variables from the command-line inputs *)    (* generate code to initialize the global input variables from the command-line inputs *)
70      fun genInitInputs (tgt, inputs) = let      fun genInitInputs (env, inputs) = let
71          (* the world pointer type *)          (* the world pointer type *)
72            val worldPtrTy = N.worldPtrTy tgt            val worldPtrTy = RN.worldPtrTy
73          (* the global state pointer type *)          (* the global state pointer type *)
74            val globPtrTy = N.globalsPtrTy tgt            val globPtrTy = RN.globalPtrTy
75          (* the inputs pointer type *)          (* the inputs pointer type *)
76            val inputPtrTy = N.inputsPtrTy tgt            val optionsPtrTy = RN.optionsPtrTy env
77          (* some common variables *)          (* some common variables *)
78            val inpV = CL.mkVar "inp"            val inpV = CL.mkVar "inp"
79            val optsV = CL.mkVar "opts"            val optsV = CL.mkVar "opts"
# Line 82  Line 82 
82           * we just copy the values.           * we just copy the values.
83           *)           *)
84            fun initInput ((gv, name, desc, optDflt), stms) = (case GVar.ty gv            fun initInput ((gv, name, desc, optDflt), stms) = (case GVar.ty gv
85                   of Ty.DynSeqTy elemTy => let                   of Ty.SeqTy(elemTy, NONE) => let
86                        val (loadFn, nDims, dims) = (case elemTy                        val (loadFn, nDims, dims) = (case elemTy
87                               of Ty.BoolTy => ("Diderot_DynSeqLoadBoolFromFile", CL.mkInt 0, CL.mkInt 0)                               of Ty.BoolTy => ("diderot::load_dynseq<bool>", CL.mkInt 0, CL.mkInt 0)
88                                | Ty.IntTy => ("Diderot_DynSeqLoadIntFromFile", CL.mkInt 0, CL.mkInt 0)                                | Ty.IntTy => ("Diderot_DynSeqLoadIntFromFile", CL.mkInt 0, CL.mkInt 0)
89                                | Ty.TensorTy[] => ("Diderot_DynSeqLoadRealFromFile", CL.mkInt 0, CL.mkInt 0)                                | Ty.TensorTy[] => ("Diderot_DynSeqLoadRealFromFile", CL.mkInt 0, CL.mkInt 0)
90                                | Ty.TensorTy _ => raise Fail "TODO: sequences of tensors"                                | Ty.TensorTy _ => raise Fail "TODO: sequences of tensors"
# Line 93  Line 93 
93                              (* end case *))                              (* end case *))
94                        in                        in
95                          CL.mkAssign(global gv,                          CL.mkAssign(global gv,
96                            CL.mkApply(loadFn, [wrldPrefix, CL.mkIndirect(inpV, GVar.name gv), nDims, dims])) ::                            CL.mkApply(loadFn, [wrldV, CL.mkIndirect(inpV, GVar.name gv), nDims, dims])) ::
97                          CL.mkIfThen(CL.mkBinOp(global gv, CL.#==, CL.mkInt 0),                          CL.mkIfThen(CL.mkBinOp(global gv, CL.#==, CL.mkInt 0),
98                            CL.mkReturn(SOME(CL.mkVar "true"))) :: stms                            CL.mkReturn(SOME(CL.mkVar "true"))) :: stms
99                        end                        end
100                    | Ty.ImageTy info => let                    | Ty.ImageTy(dim, _) => let
101                        val loadFn = (case ImageInfo.dim info                        val loadFn = (case dim
102                               of 1 => "Diderot_LoadImage1D"                               of 1 => "Diderot_LoadImage1D"
103                                | 2 => "Diderot_LoadImage2D"                                | 2 => "Diderot_LoadImage2D"
104                                | 3 => "Diderot_LoadImage3D"                                | 3 => "Diderot_LoadImage3D"
# Line 106  Line 106 
106                              (* end case *))                              (* end case *))
107                        in                        in
108                          CL.mkIfThen(                          CL.mkIfThen(
109                            CL.mkApply(loadFn, [wrldPrefix, CL.mkIndirect(inpV, GVar.name gv), CL.mkAddrOf(global gv)]),                            CL.mkApply(loadFn, [wrldV, CL.mkIndirect(inpV, GVar.name gv), CL.mkAddrOf(global gv)]),
110                            CL.mkReturn(SOME(CL.mkVar "true"))) :: stms                            CL.mkReturn(SOME(CL.mkVar "true"))) :: stms
111                        end                        end
112                    | ty => TrTy.copyFromC{ty=ty, dst=global gv, src=CL.mkIndirect(inpV, GVar.name gv)} @ stms                    | ty => TrTy.copyFromC{ty=ty, dst=global gv, src=CL.mkIndirect(inpV, GVar.name gv)} @ stms
# Line 114  Line 114 
114            in            in
115              CL.D_Func(              CL.D_Func(
116                ["static"], CL.boolTy, N.initInputs,                ["static"], CL.boolTy, N.initInputs,
117                [CL.PARAM([], worldPtrTy, "wrld"), CL.PARAM([], inputPtrTy, "inp")],                [CL.PARAM([], worldPtrTy, "wrld"), CL.PARAM([], optionsPtrTy, "inp")],
118                CL.mkBlock(                CL.mkBlock(
119                  CL.mkDeclInit(globPtrTy, "glob", CL.mkIndirect(CL.mkVar "wrld", "globals")) ::                  CL.mkDeclInit(globPtrTy, RN.globalsVar, CL.mkIndirect(CL.mkVar "wrld", "_globals")) ::
120                  List.foldr initInput [CL.mkReturn(SOME(CL.mkVar "false"))] inputs))                  List.foldr initInput [CL.mkReturn(SOME(CL.mkVar "false"))] inputs))
121            end            end
122    
# Line 129  Line 129 
129      fun genExecInputFuns (_, []) = []      fun genExecInputFuns (_, []) = []
130        | genExecInputFuns arg = U.genExecInputFuns arg @ [genInitInputs arg]        | genExecInputFuns arg = U.genExecInputFuns arg @ [genInitInputs arg]
131    
132      fun genCheckInputs (tgt, inputs) = let      fun genCheckInputs (env, inputs) = let
133          (* the world pointer type *)          (* the world pointer type *)
134            val worldPtrTy = N.worldPtrTy tgt            val worldPtrTy = N.worldPtrTy env
135            val wrldParam = CL.PARAM([], worldPtrTy, "wrld")            val wrldParam = CL.PARAM([], worldPtrTy, "wrld")
136          (* check that the specified input has been defined and, if not, define it to its default *)          (* check that the specified input has been defined and, if not, define it to its default *)
137            fun check (gv, name, _, optDflt) = let            fun check (gv, name, _, optDflt) = let
# Line 144  Line 144 
144                                    (* end case *))                                    (* end case *))
145                              in                              in
146                                case (GVar.ty gv)                                case (GVar.ty gv)
147                                 of Ty.DynSeqTy elemTy =>                                 of Ty.SeqTy(elemTy, NONE) =>
148                                      GenLoadNrrd.loadSeqFromFile (global gv, elemTy, getName())                                      GenLoadNrrd.loadSeqFromFile (global gv, elemTy, getName())
149                                  | Ty.ImageTy info =>                                  | Ty.ImageTy info =>
150                                      GenLoadNrrd.loadImage (global gv, info, getName())                                      GenLoadNrrd.loadImage (global gv, info, getName())
# Line 161  Line 161 
161                  end                  end
162            in            in
163              CL.D_Func(              CL.D_Func(
164                ["static"], CL.boolTy, N.checkDefined tgt,                ["static"], CL.boolTy, N.checkDefined env,
165                [wrldParam],                [wrldParam],
166                CL.mkBlock(List.map check inputs @ [CL.mkReturn(SOME(CL.mkBool false))]))                CL.mkBlock(List.map check inputs @ [CL.mkReturn(SOME(CL.mkBool false))]))
167            end            end
# Line 170  Line 170 
170     * exported API.     * exported API.
171     *)     *)
172      fun genInputFuns (_, []) = []      fun genInputFuns (_, []) = []
173        | genInputFuns (tgt, inputs) = let        | genInputFuns (env, inputs) = let
174          (* the world pointer type *)          (* the world pointer type *)
175            val worldPtrTy = N.worldPtrTy tgt            val worldPtrTy = RN.worldPtrTy
176            val wrldParam = CL.PARAM([], worldPtrTy, "wrld")            val wrldParam = CL.PARAM([], worldPtrTy, "wrld")
177          (* create decls for an input variable *)          (* create decls for an input variable *)
178            fun mkInputDecls (gv, name, desc, optDflt) = let            fun mkInputDecls (gv, name, desc, optDflt) = let
# Line 181  Line 181 
181                  val descDcl = (case desc                  val descDcl = (case desc
182                         of SOME desc => [                         of SOME desc => [
183                                CL.D_Var([], CL.T_Ptr(CL.T_Named "const char"),                                CL.D_Var([], CL.T_Ptr(CL.T_Named "const char"),
184                                  N.inputDesc(tgt, name),                                  N.inputDesc(env, name),
185                                  SOME(CL.I_Exp(CL.mkStr desc)))                                  SOME(CL.I_Exp(CL.mkStr desc)))
186                              ]                              ]
187                          | NONE => []                          | NONE => []
188                        (* end case *))                        (* end case *))
189                  val getDcl = if (Option.isSome optDflt)                  val getDcl = if (Option.isSome optDflt)
190                          then let                          then let
191                            val getName = N.inputGet(tgt, name)                            val getName = N.inputGet(env, name)
192                          (* generate code for a function that returns the current value of                          (* generate code for a function that returns the current value of
193                           * an input global.                           * an input global.
194                           *)                           *)
# Line 211  Line 211 
211                                  [wrldParam, CL.PARAM([], CL.T_Ptr CL.voidPtr, "v")],                                  [wrldParam, CL.PARAM([], CL.T_Ptr CL.voidPtr, "v")],
212                                  CL.mkAssign(CL.mkUnOp(CL.%*, CL.mkVar "v"), CL.mkInt 0))                                  CL.mkAssign(CL.mkUnOp(CL.%*, CL.mkVar "v"), CL.mkInt 0))
213                            val func = (case ty                            val func = (case ty
214                                   of Ty.BoolTy => mkFunc(CL.T_Ptr(trType ty))                                   of Ty.BoolTy => mkFunc(CL.T_Ptr(trType(env, ty)))
215                                    | Ty.StringTy => mkFunc(CL.T_Ptr(trType ty))                                    | Ty.StringTy => mkFunc(CL.T_Ptr(trType(env, ty)))
216                                    | Ty.IntTy => mkFunc(CL.T_Ptr(trType ty))                                    | Ty.IntTy => mkFunc(CL.T_Ptr(trType(env, ty)))
217                                    | Ty.TensorTy[] => mkFunc(CL.T_Ptr(trType ty))                                    | Ty.TensorTy[] => mkFunc(CL.T_Ptr(trType(env, ty)))
218                                    | Ty.TensorTy _ => mkFunc(trType ty)                                    | Ty.TensorTy _ => mkFunc(trType(env, ty))
219                                    | Ty.SeqTy _ => mkFunc(trType ty)                                    | Ty.SeqTy(_, SOME _) => mkFunc(trType(env, ty))
220                                    | Ty.DynSeqTy _ => nrrdFunc ()                                    | Ty.SeqTy(_, NONE) => nrrdFunc ()
221                                    | Ty.ImageTy _ => nrrdFunc ()                                    | Ty.ImageTy _ => nrrdFunc ()
222                                    | _ => raise Fail(concat["bogus input type ", Ty.toString ty])                                    | _ => raise Fail(concat["bogus input type ", Ty.toString ty])
223                                  (* end case *))                                  (* end case *))
# Line 228  Line 228 
228                  val setDcl = (case ty                  val setDcl = (case ty
229                         of Ty.ImageTy info => [                         of Ty.ImageTy info => [
230                                CL.D_Func(                                CL.D_Func(
231                                  [], CL.boolTy, N.inputSetByName(tgt, name),                                  [], CL.boolTy, N.inputSetByName(env, name),
232                                  [wrldParam, CL.PARAM(["const"], CL.charPtr, "s")],                                  [wrldParam, CL.PARAM(["const"], CL.charPtr, "s")],
233                                  CL.appendStm(                                  CL.appendStm(
234                                    GenLoadNrrd.loadImage (global gv, info, CL.mkVar "s"),                                    GenLoadNrrd.loadImage (global gv, info, CL.mkVar "s"),
235                                    CL.mkReturn(SOME(CL.mkBool false)))),                                    CL.mkReturn(SOME(CL.mkBool false)))),
236                                CL.D_Func(                                CL.D_Func(
237                                  [], CL.boolTy, N.inputSet(tgt, name),                                  [], CL.boolTy, N.inputSet(env, name),
238                                  [wrldParam, CL.PARAM([], nrrdPtrTy, "nin")],                                  [wrldParam, CL.PARAM([], nrrdPtrTy, "nin")],
239                                  CL.appendStm(                                  CL.appendStm(
240                                    GenLoadNrrd.setImage (global gv, info, CL.mkVar "nin"),                                    GenLoadNrrd.setImage (global gv, info, CL.mkVar "nin"),
241                                    CL.mkReturn(SOME(CL.mkBool false))))                                    CL.mkReturn(SOME(CL.mkBool false))))
242                              ]                              ]
243                          | Ty.DynSeqTy elemTy => [                          | Ty.SeqTy(elemTy, NONE) => [
244                                CL.D_Func(                                CL.D_Func(
245                                  [], CL.boolTy, N.inputSetByName(tgt, name),                                  [], CL.boolTy, N.inputSetByName(env, name),
246                                  [wrldParam, CL.PARAM(["const"], CL.charPtr, "s")],                                  [wrldParam, CL.PARAM(["const"], CL.charPtr, "s")],
247                                  CL.appendStm(                                  CL.appendStm(
248                                    GenLoadNrrd.loadSeqFromFile (global gv, elemTy, CL.mkVar "s"),                                    GenLoadNrrd.loadSeqFromFile (global gv, elemTy, CL.mkVar "s"),
249                                    CL.mkReturn(SOME(CL.mkBool false)))),                                    CL.mkReturn(SOME(CL.mkBool false)))),
250                                CL.D_Func(                                CL.D_Func(
251                                  [], CL.boolTy, N.inputSet(tgt, name),                                  [], CL.boolTy, N.inputSet(env, name),
252                                  [wrldParam, CL.PARAM([], nrrdPtrTy, "nin")],                                  [wrldParam, CL.PARAM([], nrrdPtrTy, "nin")],
253                                  CL.appendStm(                                  CL.appendStm(
254                                    GenLoadNrrd.loadSeq (global gv, elemTy, CL.mkVar "nin"),                                    GenLoadNrrd.loadSeq (global gv, elemTy, CL.mkVar "nin"),
# Line 256  Line 256 
256                              ]                              ]
257                          | _ => [                          | _ => [
258                                CL.D_Func(                                CL.D_Func(
259                                  [], CL.boolTy, N.inputSet(tgt, name),                                  [], CL.boolTy, N.inputSet(env, name),
260                                  [wrldParam, CL.PARAM([], trType ty, "v")],                                  [wrldParam, CL.PARAM([], trType(env, ty), "v")],
261                                  CL.mkBlock(                                  CL.mkBlock(
262                                    CL.mkAssign(U.defined gv, CL.mkBool true) ::                                    CL.mkAssign(U.defined gv, CL.mkBool true) ::
263                                    TrTy.copyFromC{ty=ty, dst=global gv, src=CL.mkVar "v"} @                                    TrTy.copyFromC{ty=ty, dst=global gv, src=CL.mkVar "v"} @
# Line 268  Line 268 
268                    (descDcl @ getDcl @ setDcl)                    (descDcl @ getDcl @ setDcl)
269                  end                  end
270            val extras = [            val extras = [
271                    genCheckInputs (tgt, inputs),                    genCheckInputs (env, inputs),
272                    U.genDefineInp (tgt, inputs)                    U.genDefineInp (env, inputs)
273                  ]                  ]
274            in            in
275              List.foldr (fn (input, dcls) => mkInputDecls input @ dcls) extras inputs              List.foldr (fn (input, dcls) => mkInputDecls input @ dcls) extras inputs

Legend:
Removed from v.3909  
changed lines
  Added in v.3910

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