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

SCM Repository

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

Diff of /branches/vis12/src/compiler/c-target/gen-output.sml

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

revision 1707, Thu Mar 8 12:13:35 2012 UTC revision 1708, Fri Mar 9 12:46:42 2012 UTC
# Line 26  Line 26 
26            end            end
27    
28  (* cases:  (* cases:
29   *      grid, fixed-size elements   *      grid, fixed-size elements:
30     *              nrrd has object dimensions followed by axes
31   *      collection, fixed-size elements   *      collection, fixed-size elements
32     *              nrrd has object dims followed by a single axis
33   *      grid, dynamic-size elements   *      grid, dynamic-size elements
34     *              lengths nrrd has size 2 for objects (offset, length) followed by axes
35     *              data nrrd has object dimensions followed by a single axis
36   *      collection, dynamic-size elements   *      collection, dynamic-size elements
37     *              lengths nrrd has size 2 for objects (offset, length) followed by a single axis
38     *              data nrrd has object dimensions followed by a single axis
39   *)   *)
40    
41      val nrrdPtrTy = CL.T_Ptr(CL.T_Named "Nrrd")      val nrrdPtrTy = CL.T_Ptr(CL.T_Named "Nrrd")
# Line 37  Line 43 
43    
44      fun mkInt i = CL.mkInt(IntInf.fromInt i)      fun mkInt i = CL.mkInt(IntInf.fromInt i)
45    
 (* FIXME: this is a copy of the function in gen-library-interface.sml *)  
   (* translate TreeIL types to CLang types *)  
     fun trType ty = (case ty  
            of Ty.BoolTy => CL.T_Named "bool"  
             | Ty.StringTy => CL.charPtr  
             | Ty.IntTy => !N.gIntTy  
             | Ty.TensorTy[] => !N.gRealTy  
             | Ty.TensorTy[n] => CL.T_Array(!N.gRealTy, SOME n)  
             | Ty.TensorTy[n, m] => CL.T_Array(CL.T_Array(!N.gRealTy, SOME n), SOME m)  
             | Ty.TensorTy[n, m, l] => CL.T_Array(CL.T_Array(CL.T_Array(!N.gRealTy, SOME n), SOME m), SOME l)  
             | Ty.SeqTy(Ty.IntTy, n) => CL.T_Array(!N.gIntTy, SOME n)  
             | Ty.SeqTy(ty, n) => CL.T_Array(trType ty, SOME n)  
             | Ty.DynSeqTy _ => CL.T_Ptr(CL.T_Named N.dynSeqTy)  
             | Ty.AddrTy(ImageInfo.ImgInfo{ty=(_, rTy), ...}) => CL.T_Ptr(CL.T_Num rTy)  
             | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) => CL.T_Ptr(CL.T_Named(N.imageTy dim))  
             | _ => raise Fail(concat["GetOutput.trType(", Ty.toString ty, ")"])  
           (* end case *))  
   
46      fun infoOf (tgt : TargetUtil.target_desc, ty) = (case ty      fun infoOf (tgt : TargetUtil.target_desc, ty) = (case ty
47             of Ty.IntTy => if #longint tgt             of Ty.IntTy => if #longint tgt
48                  then (CL.int64, "nrrdTypeLLong", [1])                  then (CL.int64, "nrrdTypeLLong", [1])
# Line 78  Line 66 
66      val sizesV = CL.mkVar "sizes"      val sizesV = CL.mkVar "sizes"
67      val iV = CL.mkVar "i"      val iV = CL.mkVar "i"
68      val pV = CL.mkVar "p"      val pV = CL.mkVar "p"
69      val nrrdV = CL.mkVar "nrrd"      val dataV = CL.mkVar "data"
70      val numStableV = CL.mkVar "numStableV"      val lengthsV = CL.mkVar "lengths"
71        val numStableV = CL.mkVar "numStable"
72        val numElemsV = CL.mkVar "numElems"
73      val DIDEROT_STABLE = CL.mkVar "DIDEROT_STABLE"      val DIDEROT_STABLE = CL.mkVar "DIDEROT_STABLE"
74        val NRRD = CL.mkVar "NRRD"
75    
76    (* code fragment for counting the number of stable strands    (* dymanic sequence operations *)
77          size_t numStabilized = 0;      fun seqLength arg = CL.mkApply("Diderot_DynSeqLength", [arg])
78          for (unsigned int i = 0;  i < wrld->numStrands;  i++) {      fun seqCopy (elemSz, dst, seq) = CL.mkApply("Diderot_DynSeqCopy", [elemSz, dst, seq])
79              if (wrld->status[i] == DIDEROT_STABLE)  
80                  numStabilized++;    (* code to access state variable
81          }          wrld->outState[i].name
82    *)    *)
83      val countStable = [      fun stateVar name = CL.mkIndirect(CL.mkSubscript(CL.mkIndirect(wrldV, "outState"), iV), name)
84              CL.mkDecl(sizeTy, "numStable", SOME(CL.I_Exp(mkInt 0))),  
85              CL.mkFor(    (* code fragment to loop over strands
86            for (unsigned int i = 0;  i < wrld->numStrands;  i++) ...
87       *)
88        fun forStrands stm = CL.mkFor(
89                [(CL.uint32, "i", mkInt 0)],                [(CL.uint32, "i", mkInt 0)],
90                CL.mkBinOp(iV, CL.#<, CL.mkIndirect(wrldV, "numStrands")),                CL.mkBinOp(iV, CL.#<, CL.mkIndirect(wrldV, "numStrands")),
91                [CL.mkPostOp(numStableV, CL.^++)],                [CL.mkPostOp(numStableV, CL.^++)],
92                CL.mkIfThen(            stm)
93    
94      (* code fragment to test for stable strands in a loop
95            if (wrld->status[i] == DIDEROT_STABLE)
96                ...
97       *)
98        fun ifStable stm = CL.mkIfThen(
99                  CL.mkBinOp(CL.mkSubscript(CL.mkIndirect(wrldV, "status"), iV), CL.#==, DIDEROT_STABLE),                  CL.mkBinOp(CL.mkSubscript(CL.mkIndirect(wrldV, "status"), iV), CL.#==, DIDEROT_STABLE),
100                  CL.S_Exp(CL.mkPostOp(numStableV, CL.^++))))            stm)
101    
102      (* code fragment to allocate nrrd data and check for errors
103            if (nrrdMaybeAlloc_nva(<nrrdVar>, <nrrdType>, <nDims>, sizes) != 0) {
104                wrld->err = biffGetDone(NRRD);
105                return true;
106            }
107       *)
108        fun maybeAlloc (nrrdVar, nrrdType, nDims) =
109              CL.mkIfThen(
110                CL.mkBinOp(
111                  CL.mkApply("nrrdMaybeAlloc_nva", [
112                      nrrdVar, CL.mkVar nrrdType, mkInt nDims, sizesV
113                    ]),
114                  CL.#!=,
115                  CL.mkInt 0),
116              (* then *)
117                CL.mkBlock[
118                    CL.mkAssign(CL.mkIndirect(wrldV, "err"),
119                      CL.mkApply("biffGetDone", [NRRD])),
120                    CL.mkReturn(SOME(CL.mkVar "true"))
121            ]            ]
122              (* endif*))
123    
124      fun genDynOutput (tgt, isArray, ty, name) = raise Fail "genDynOutput"    (* create the body of an output function for dynamic-size outputs.  The structure of the
125       * function body is:
126       *
127       *    declarations
128       *    compute sizes array for lengths
129       *    allocate nrrd for lengths
130       *    compute sizes array for data
131       *    allocate nrrd for data
132       *    copy data from strands to nrrd
133       *)
134        fun genDynOutput (tgt, nAxes, ty, name) = let
135              val (elemCTy, nrrdType, dims) = infoOf (tgt, ty)
136              val nDims = List.length dims
137              val nElems = List.foldl Int.* 1 dims
138              val (isArray, nAxes) = (case nAxes of NONE => (false, 1) | SOME n => (true, n))
139            (* declarations *)
140              val decls = [
141                      CL.mkDecl(CL.T_Array(sizeTy, SOME(nDims+nAxes)), "sizes", NONE),
142                      CL.mkDecl(CL.charPtr, "p", NONE)
143                    ]
144            (* count number of elements (and stable strands) *)
145              val countElems = let
146                    val nElemsInit = CL.mkAssign(numElemsV, CL.mkInt 0)
147                    val cntElems = CL.S_Exp(CL.mkAssignOp(numElemsV, CL.+=, seqLength(stateVar name)))
148                    in
149                      if isArray
150                        then [
151                            CL.mkComment["count number of elements"],
152                            nElemsInit, forStrands cntElems
153                          ]
154                        else [
155                            CL.mkComment["count number of elements and stable strands"],
156                            CL.mkAssign(numStableV, CL.mkInt 0), nElemsInit,
157                            forStrands(ifStable(CL.mkBlock[cntElems, CL.S_Exp(CL.mkPostOp(numStableV, CL.^++))]))
158                          ]
159                    end
160            (* generate code to allocate lengths nrrd *)
161              val lengthsNrrd = let
162                    fun sizes i = CL.mkSubscript(sizesV, mkInt i)
163                    fun setSizes (i, v) = CL.mkAssign(sizes i, v)
164                    val dimSizes = setSizes(0, CL.mkInt 2)  (* lengths is 2-element vector *)
165                    in
166                      if isArray
167                        then dimSizes ::
168                          List.tabulate (nAxes, fn i =>
169                            setSizes(i+1, CL.mkSubscript(CL.mkIndirect(wrldV, "sizes"), mkInt(nAxes-i-1))))
170                        else [
171                            CL.mkDecl(sizeTy, "numStable", SOME(CL.I_Exp(mkInt 0))),
172                            forStrands (ifStable(CL.S_Exp(CL.mkPostOp(numStableV, CL.^++)))),
173                            dimSizes, setSizes(nDims, numStableV)
174                          ]
175                    end
176            (* generate code to allocate data nrrd *)
177              val dataNrrd = []
178            (* generate the lengths copy code *)
179              val copyLengths = []
180            (* generate the data copy code *)
181              val copyData = []
182            (* the function body *)
183              val stms =
184                    decls @
185                    countElems @
186                    lengthsNrrd @
187                    dataNrrd @
188                    copyLengths @
189                    copyData @
190                    [CL.mkReturn(SOME(CL.mkVar "false"))]
191              in
192                ([CL.PARAM([], nrrdPtrTy, "lengths"), CL.PARAM([], nrrdPtrTy, "data")], CL.mkBlock stms)
193              end
194    
195    (* create the body of an output function for fixed-size outputs.  The structure of the    (* create the body of an output function for fixed-size outputs.  The structure of the
196     * function body is:     * function body is:
# Line 125  Line 215 
215                      then dimSizes @                      then dimSizes @
216                        List.tabulate (nAxes, fn i =>                        List.tabulate (nAxes, fn i =>
217                          setSizes(nDims+i, CL.mkSubscript(CL.mkIndirect(wrldV, "sizes"), mkInt(nAxes-i-1))))                          setSizes(nDims+i, CL.mkSubscript(CL.mkIndirect(wrldV, "sizes"), mkInt(nAxes-i-1))))
218                      else countStable @ dimSizes @ [setSizes(nDims, numStableV)]                      else
219                          CL.mkDecl(sizeTy, "numStable", SOME(CL.I_Exp(mkInt 0))) ::
220                          forStrands (ifStable(CL.S_Exp(CL.mkPostOp(numStableV, CL.^++)))) ::
221                          dimSizes @ [setSizes(nDims, numStableV)]
222                  end                  end
223          (* generate the copy code *)          (* generate the copy code *)
224            val copyCode = let            val copyCode = let
225                  val pDecl = CL.mkDecl(CL.charPtr, "p", SOME(CL.I_Exp(                  val pDecl = CL.mkDecl(CL.charPtr, "p", SOME(CL.I_Exp(
226                          CL.mkCast(CL.charPtr, CL.mkIndirect(nrrdV, "data")))))                          CL.mkCast(CL.charPtr, CL.mkIndirect(dataV, "data")))))
227                  val copyCore = CL.mkBlock[                  val copyCore = CL.mkBlock[
228                          CL.mkCall("memcpy", [                          CL.mkCall("memcpy", [
229                              pV,                              pV,
230                              CL.mkUnOp(CL.%&,                              CL.mkUnOp(CL.%&, stateVar name),
                               CL.mkIndirect(  
                                 CL.mkSubscript(CL.mkIndirect(wrldV, "outState"), iV), name)),  
231                              CL.mkBinOp(mkInt nDims, CL.#*, CL.mkSizeof elemCTy)                              CL.mkBinOp(mkInt nDims, CL.#*, CL.mkSizeof elemCTy)
232                            ]),                            ]),
233                          CL.mkExpStm(CL.mkAssignOp(pV, CL.+=, CL.mkSizeof elemCTy))                          CL.mkExpStm(CL.mkAssignOp(pV, CL.+=, CL.mkSizeof elemCTy))
234                        ]                        ]
                 fun mkLoop stm = CL.mkFor(  
                       [(CL.uint32, "i", CL.mkInt 0)],  
                       CL.mkBinOp(iV, CL.#<, CL.mkIndirect(wrldV, "numStrands")),  
                       [CL.mkPostOp(iV, CL.^++)],  
                       stm)  
235                  in                  in
236                    if isArray                    if isArray
237                      then [pDecl, mkLoop copyCore]                      then [pDecl, forStrands copyCore]
238                      else raise Fail "FIXME"                      else raise Fail "FIXME"
239                  end                  end
240          (* the function body *)          (* the function body *)
# Line 157  Line 243 
243                  CL.mkDecl(sizeTy, "sizes", NONE) ::                  CL.mkDecl(sizeTy, "sizes", NONE) ::
244                  initSizes @                  initSizes @
245                  CL.mkComment["Allocate nrrd data"] ::                  CL.mkComment["Allocate nrrd data"] ::
246                (*                  maybeAlloc (dataV, nrrdType, nDims+nAxes) ::
                   if (nrrdMaybeAlloc_nva(nrrd, nrrdFloatType, 3, sizes) != 0) {  
                       wrld->err = biffGetDone(NRRD);  
                       return true;  
                   }  
               *)  
                 CL.mkIfThen(  
                   CL.mkBinOp(  
                     CL.mkApply("nrrdMaybeAlloc_nva", [  
                         CL.mkVar "nrrd", CL.mkVar nrrdType, mkInt(nDims+nAxes), CL.mkVar "sizes"  
                       ]),  
                     CL.#!=,  
                     CL.mkInt 0),  
                 (* then *)  
                   CL.mkBlock[  
                       CL.mkAssign(CL.mkIndirect(CL.mkVar "wrld", "err"),  
                         CL.mkApply("biffGetDone", [CL.mkVar "NRRD"])),  
                       CL.mkReturn(SOME(CL.E_Var "true"))  
                     ]  
                 (* endif*)) ::  
247                  CL.mkComment["copy data to output nrrd"] ::                  CL.mkComment["copy data to output nrrd"] ::
248                  copyCode @                  copyCode @
249                  [CL.mkReturn(SOME(CL.E_Var "false"))]                  [CL.mkReturn(SOME(CL.mkVar "false"))]
250            in            in
251              ([CL.PARAM([], nrrdPtrTy, "nrrd")], CL.mkBlock stms)              ([CL.PARAM([], nrrdPtrTy, "data")], CL.mkBlock stms)
252            end            end
253    
254      fun gen (tgt : TargetUtil.target_desc, nAxes) (ty, name) = let      fun gen (tgt : TargetUtil.target_desc, nAxes) (ty, name) = let

Legend:
Removed from v.1707  
changed lines
  Added in v.1708

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