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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/c-util/tree-to-c-fn.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/c-util/tree-to-c-fn.sml

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

revision 2837, Wed Nov 19 23:42:17 2014 UTC revision 2838, Tue Nov 25 03:40:24 2014 UTC
# Line 93  Line 93 
93    
94      (*creates global var if it's not a vector type*)      (*creates global var if it's not a vector type*)
95      fun localType(ty,isVecTy) = (case ty      fun localType(ty,isVecTy) = (case ty
96          of Ty.TensorTy [3] => CLang.T_Named(N.LocalTy [3])          of Ty.TensorTy[]=> !N.gRealTy
97            | Ty.TensorTy[1]=> !N.gRealTy
98            | Ty.TensorTy [3]=>CLang.T_Named(N.LocalTy [4])
99          | Ty.TensorTy [t] =>(case (isVecTy t)          | Ty.TensorTy [t] =>(case (isVecTy t)
100              of true => CLang.T_Named(N.LocalTy [t])              of true => CLang.T_Named(N.LocalTy [t])
101              | _ => trType ty              | _ => trType ty
# Line 163  Line 165 
165    
166          CL.mkSubscript(CL.mkSubscript(m, ix), jx)          CL.mkSubscript(CL.mkSubscript(m, ix), jx)
167    
168    
169    fun dumpStore ([])=[]
170    | dumpStore (Dst.E_Mux(_,_,_,_,ops)::es)=ops@dumpStore es
171    | dumpStore (e1::es)=[e1] @dumpStore es
172    
173    
174    (* Translate a TreeIL operator application to a CLang expression *)    (* Translate a TreeIL operator application to a CLang expression *)
175      fun trOp (rator, args) = (case (rator, args)      fun trOp (rator, args) = (case (rator, args)
176             of (Op.IAdd , [a, b]) => CL.mkBinOp(a, CL.#+, b)             of (Op.IAdd , [a, b]) => CL.mkBinOp(a, CL.#+, b)
# Line 180  Line 188 
188              | (Op.clampVec n, args) => CL.mkApply(N.NameClampV n, args)              | (Op.clampVec n, args) => CL.mkApply(N.NameClampV n, args)
189              | (Op.lerpVec n, args) =>  CL.mkApply(N.NameLerpV n, args)              | (Op.lerpVec n, args) =>  CL.mkApply(N.NameLerpV n, args)
190              | (Op.Sqrt,[a])         =>       CL.E_Sqrt a              | (Op.Sqrt,[a])         =>       CL.E_Sqrt a
191                | (Op.prodScaV 1,[a,b])   =>  CL.mkBinOp(a, CL.#*, b)
192              | (Op.prodScaV d,args)   => CL.E_Apply(N.NameScaV d, args)              | (Op.prodScaV d,args)   => CL.E_Apply(N.NameScaV d, args)
193                | (Op.sumVec (1,_),[a])     => a
194              | (Op.sumVec (nSize,oSize),args)     => CL.E_Apply(N.NameSumV oSize, args)              | (Op.sumVec (nSize,oSize),args)     => CL.E_Apply(N.NameSumV oSize, args)
195    
196    
197    
198                | (Op.IndexTensor(true,Ty.indexTy [0],Ty.TensorTy[1]),[a])=> a
199              | (Op.IndexTensor(true,Ty.indexTy [i],Ty.TensorTy[n]),[a])=> vecIndex (a,n,i) (*Index Local Vector*)              | (Op.IndexTensor(true,Ty.indexTy [i],Ty.TensorTy[n]),[a])=> vecIndex (a,n,i) (*Index Local Vector*)
200              | (Op.IndexTensor(false,Ty.indexTy [i],Ty.TensorTy[_]),[a])=>prntArr(a,i)   (*Index Global Vector*)              | (Op.IndexTensor(false,Ty.indexTy [i],Ty.TensorTy[_]),[a])=>prntArr(a,i)   (*Index Global Vector*)
             | (Op.IndexTensor(_,Ty.indexTy[i,j] ,Ty.TensorTy[_,m]),[a])=>prntArr(a,m*i+j)  
201              | (Op.IndexTensor(_,Ty.indexTy [i],Ty.SeqTy (_,n)),[a])=> ivecIndex (a,n,i)              | (Op.IndexTensor(_,Ty.indexTy [i],Ty.SeqTy (_,n)),[a])=> ivecIndex (a,n,i)
202                | (Op.IndexTensor(_,Ty.indexTy[i,j] ,Ty.TensorTy[_,m]),[a])=>prntArr(a,m*i+j)
203                | (Op.IndexTensor(_,Ty.indexTy[i,j,k] ,Ty.TensorTy[_,m,n]),[a])=>prntArr(a,m*i+n*j+k)
204    
205    
206                  (*Image related operators*)                  (*Image related operators*)
207               | (Op.baseAddr(ImageInfo.ImgInfo{ty=(_,rTy), ...}) ,[a])=>               | (Op.baseAddr(ImageInfo.ImgInfo{ty=(_,rTy), ...}) ,[a])=>
# Line 199  Line 214 
214                  | [i]  => CL.mkBinOp(CL.mkInt(IntInf.fromInt i), CL.#+, CL.mkBinOp(base, CL.#+,shift))                  | [i]  => CL.mkBinOp(CL.mkInt(IntInf.fromInt i), CL.#+, CL.mkBinOp(base, CL.#+,shift))
215                  | _    =>raise Fail"Img addr larger than vector"                  | _    =>raise Fail"Img addr larger than vector"
216                  (*end case*))                  (*end case*))
217              | (Op.Transform(_,i),[a]) => CL.mkIndirect(a, "w2i["^(Int.toString i)^"].v")              | (Op.Transform(v,i),[a]) =>(case (ImageInfo.dim v)
218              | (Op.Translate(ImageInfo.ImgInfo{ty=(_,rTy), ...}),[a])=>CL.mkIndirect(a, "tVec")                  of 1=>CL.mkIndirect(a, "s")
219                    | _ =>CL.mkIndirect(a, "w2i["^(Int.toString i)^"].v")
220                    (*end case*))
221                | (Op.Translate(v as ImageInfo.ImgInfo{ty=(_,rTy), ...}),[a])=>(case (ImageInfo.dim v)
222                    of 1=>CL.mkIndirect(a, "t")
223                    | _ =>CL.mkIndirect(a, "tVec")
224                    (*end case*))
225              | (Op.Abs(Ty.IntTy), args) => CL.mkApply("abs", args)              | (Op.Abs(Ty.IntTy), args) => CL.mkApply("abs", args)
226              | (Op.Abs(Ty.TensorTy[]), args) => CL.mkApply(N.fabs(), args)              | (Op.Abs(Ty.TensorTy[]), args) => CL.mkApply(N.fabs(), args)
227              | (Op.Abs ty, [a]) => raise Fail(concat["Abs<", Ty.toString ty, ">"])              | (Op.Abs ty, [a]) => raise Fail(concat["Abs<", Ty.toString ty, ">"])
# Line 229  Line 250 
250                  end                  end
251              | (Op.Subscript(Ty.SeqTy(ty, n)), [v, ix]) => CL.mkSubscript(v, ix)              | (Op.Subscript(Ty.SeqTy(ty, n)), [v, ix]) => CL.mkSubscript(v, ix)
252              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let
253                  val unionTy = CL.T_Named(concat["Onionunion", Int.toString n, !N.gRealSuffix, "_t"])                  val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gRealSuffix, "_t"])
254                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")
255                  in                  in
256                    CL.mkSubscript(vecExp, ix)                    CL.mkSubscript(vecExp, ix)
# Line 238  Line 259 
259              | (Op.Subscript ty, t::(ixs as _::_)) =>              | (Op.Subscript ty, t::(ixs as _::_)) =>
260                  raise Fail(concat["Subscript<", Ty.toString ty, "> unsupported"])                  raise Fail(concat["Subscript<", Ty.toString ty, "> unsupported"])
261              | (Op.Ceiling d, args) => CL.mkApply(N.addTySuffix("ceil", d), args)              | (Op.Ceiling d, args) => CL.mkApply(N.addTySuffix("ceil", d), args)
262                | (Op.Floor 1, args) => CL.mkApply(N.NameFloor , args)
263              | (Op.Floor d, args) => CL.mkApply(N.NameFloorV d, args)              | (Op.Floor d, args) => CL.mkApply(N.NameFloorV d, args)
264              | (Op.Round d, args) => CL.mkApply(N.addTySuffix("round", d), args)              | (Op.Round d, args) => CL.mkApply(N.addTySuffix("round", d), args)
265              | (Op.Trunc d, args) => CL.mkApply(N.addTySuffix("trunc", d), args)              | (Op.Trunc d, args) => CL.mkApply(N.addTySuffix("trunc", d), args)
# Line 245  Line 267 
267              | (Op.RealToInt 1, [a]) => CL.mkCast(!N.gIntTy, a)              | (Op.RealToInt 1, [a]) => CL.mkCast(!N.gIntTy, a)
268              | (Op.RealToInt d, args) => CL.mkApply(N.vecftoi d, args)              | (Op.RealToInt d, args) => CL.mkApply(N.vecftoi d, args)
269  (* FIXME: need type info *)  (* FIXME: need type info *)
270                | (Op.Normalize d,args)=>CL.mkApply(N.normalize d, args)
271    
272                      (*Replaced with baseAddr operator*)                      (*Replaced with baseAddr operator*)
273              | (Op.ImageAddress(ImageInfo.ImgInfo{ty=(_,rTy), ...}), [a]) =>  CL.mkIndirect(a, "data")              | (Op.ImageAddress(ImageInfo.ImgInfo{ty=(_,rTy), ...}), [a]) =>  CL.mkIndirect(a, "data")
# Line 271  Line 294 
294            (* end case *))            (* end case *))
295    
296      fun trExp (env, e) = (case e      fun trExp (env, e) = (case e
297             of IL.E_State x => VarToC.rvalueStateVar x              of IL.E_State x => (VarToC.rvalueStateVar x)
298              | IL.E_Var x => VarToC.rvalueVar (env, x)              | IL.E_Var x => VarToC.rvalueVar (env, x)
299              | IL.E_Lit(Literal.Int n) => CL.mkIntTy(n, !N.gIntTy)              | IL.E_Lit(Literal.Int n) => CL.mkIntTy(n, !N.gIntTy)
300              | IL.E_Lit(Literal.Bool b) => CL.mkBool b              | IL.E_Lit(Literal.Bool b) => CL.mkBool b
# Line 279  Line 302 
302              | IL.E_Lit(Literal.String s) => CL.mkStr s              | IL.E_Lit(Literal.String s) => CL.mkStr s
303              | IL.E_Op(rator, args) => trOp (rator, trExps(env, args))              | IL.E_Op(rator, args) => trOp (rator, trExps(env, args))
304              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))
305              | IL.E_Cons(nSize,oSize,args) =>  CL.mkApply(N.NameConsVec nSize, trExps(env, args))              | IL.E_Cons(nSize,1,args) => (case (dumpStore args)
306                    of [a1]=>  trExp(env, a1)
307                    | _=>CL.mkApply(N.NameConsVec nSize, trExps(env, dumpStore args))
308                    (*end case*))
309                | IL.E_Cons(nSize,oSize,args) =>  CL.mkApply(N.NameConsVec nSize, trExps(env, dumpStore args))
310                | IL.E_LoadArr(_,1, _, v,IL.E_Lit(Literal.Int i)) =>                    CL.mkSubscript(trExp(env,v),CL.mkIntTy(  i,!N.gIntTy))
311              | IL.E_LoadArr(aligned,n, orig, v,arg) =>              | IL.E_LoadArr(aligned,n, orig, v,arg) =>
312                      CL.mkApply(N.NameLdArr(aligned,n,orig), trExps(env, [v,arg]))                      CL.mkApply(N.NameLdArr(aligned,n,orig), trExps(env, [v,arg]))
313              | IL.E_Mux (_,_,_,_,[a1]) => trExp(env,a1)              | IL.E_Mux (_,_,_,_,[a1]) => trExp(env,a1)
314               | IL.E_Mux (_,_,n,_,args) => (*raise Fail "Mux in tree-il stage, try trExp()"*)
315              | IL.E_Mux (_,_,_,_,args) => (*raise Fail "Mux in tree-il stage, try trExp()"*)                      CL.mkApply(N.NameMux n, trExps(env, args))
                     CL.mkApply(N.NameMux, trExps(env, args))  
316               | IL.E_Holder (x,_) => CL.mkStr ("Holder for "^(V.name x))               | IL.E_Holder (x,_) => CL.mkStr ("Holder for "^(V.name x))
317                      (*VarToC.rvalueVar (env, x)*)                      (*VarToC.rvalueVar (env, x)*)
318            (* end case *))            (* end case *))
319      and trExps (env, exps) = List.map (fn exp => trExp(env, exp)) exps                      and trExps (env, exps) = (List.map (fn exp => trExp(env, exp)) exps)
320    
321    
322      fun storeVec(env,x',offset,A, isFill, oSize,ty,pieces,args)=let      fun storeVec(env,x',offset,A, isFill, oSize,ty,pieces,args)=let
   
         fun dumpStore ([])=[]  
           | dumpStore (Dst.E_Mux(_,_,_,_,ops)::es)=ops@dumpStore es  
           | dumpStore (e1::es)=[e1] @dumpStore es  
323          val args'=dumpStore args          val args'=dumpStore args
324    
325          val exp= if(isFill) then (*isFilled used*)          val exp= if(isFill) then (*isFilled used*)
326              let              let
327                  fun sort([],_,_)=[]                  fun sort([],_,_)=[]
328                  | sort(nSize::ps,e::es,offset)= [CL.mkApply(N.NameMkVec(A,nSize,oSize),                  | sort(nSize::ps,e::es,offset)=
329                      [x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]  @ sort(ps, es,offset + IntInf.fromInt oSize)                      [CL.mkApply(N.NameMkVec(A,nSize,oSize), [x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]
330                        @ sort(ps, es,offset + IntInf.fromInt oSize)
331              in sort(pieces,args',IntInf.fromInt offset) end              in sort(pieces,args',IntInf.fromInt offset) end
332              else let              else let
333                  fun sort([],_,_)=[]                  fun sort([],_,_)=[]
334                  | sort(nSize::ps,e::es,offset)= [CL.mkApply(N.NameMkVec(A,nSize,oSize),                  | sort(nSize::ps,e::es,offset)=
335                      [x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]  @ sort(ps, es,offset + IntInf.fromInt nSize)                      [CL.mkApply(N.NameMkVec(A,nSize,oSize),[x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]
336                        @ sort(ps, es,offset + IntInf.fromInt nSize)
337              in sort(pieces,args', IntInf.fromInt offset) end              in sort(pieces,args', IntInf.fromInt offset) end
338          in          in
339              List.map (fn e=> CL.S_Exp e ) exp              List.map (fn e=> CL.S_Exp e ) exp
# Line 450  Line 475 
475                        matIndex (m, CL.mkInt 2, CL.mkInt 2)                        matIndex (m, CL.mkInt 2, CL.mkInt 2)
476                      ])]                      ])]
477                  end                  end
478                |IL.E_Op(Op.Zero(Ty.TensorTy ty),args)=> [CL.mkCall(N.NameZeroV ty, [lhs])]
479                          (*
480              | IL.E_Op(Op.Zero(Ty.TensorTy[n]), args) =>              | IL.E_Op(Op.Zero(Ty.TensorTy[n]), args) =>
481                        [CL.mkCall(N.zeroVec(n), [lhs])]                        [CL.mkCall(N.zeroVec(n), [lhs])]
482              | IL.E_Op(Op.Zero(Ty.TensorTy[m,n]), args) =>              | IL.E_Op(Op.Zero(Ty.TensorTy[m,n]), args) =>
483                  [CL.mkCall(N.zeroMat(m,n), [lhs])]                  [CL.mkCall(N.zeroMat(m,n), [lhs])]*)
484               (*Op.imgLoad(info ,dim, n),[a])=>               (*Op.imgLoad(info ,dim, n),[a])=>
485                  if (n > 1)                  if (n > 1)
486                    then let                    then let
# Line 542  Line 569 
569              | _             => raise Fail "NonVar in exp"              | _             => raise Fail "NonVar in exp"
570          (*end case *))          (*end case *))
571    
572              fun trStmt (env, stm) = (case stm          fun trStmt (env, stm) = let
573    
574                in  case stm
575                   of IL.S_Comment text => [CL.mkComment text]                   of IL.S_Comment text => [CL.mkComment text]
576                    | IL.S_Assign([x], exp) =>                    | IL.S_Assign([x], exp) =>
577                          trAssign (env, VarToC.lvalueVar (env, x) , exp)                          trAssign (env, VarToC.lvalueVar (env, x) , exp)
# Line 566  Line 595 
595    
596                    | IL.S_Save([x],exp) => (trAssign (env, VarToC.lvalueStateVar x, exp))                    | IL.S_Save([x],exp) => (trAssign (env, VarToC.lvalueStateVar x, exp))
597                    | IL.S_Save(xs, exp) =>                    | IL.S_Save(xs, exp) =>
598                          trMultiAssign (env, List.map VarToC.lvalueStateVar xs, exp)                          (trMultiAssign (env, List.map VarToC.lvalueStateVar xs, exp))
599                   | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let                   | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let
600    
601                        val lhs = VarToC.lvalueVar (env, lhs)                        val lhs = VarToC.lvalueVar (env, lhs)
# Line 605  Line 634 
634                      end                      end
635                    | IL.S_Cons(x,n,args)=>  [CL.S_Exp (CL.mkApply(N.NameConsArray n, [VarToC.lvalueVar (env, x)]@trExps(env, args)))]                    | IL.S_Cons(x,n,args)=>  [CL.S_Exp (CL.mkApply(N.NameConsArray n, [VarToC.lvalueVar (env, x)]@trExps(env, args)))]
636    
637                  (* end case *))                  (* end case *)
638                   end
639            in            in
640              List.foldr (fn (stm, stms) => trStmt(env, stm)@stms) [] stms              List.foldr (fn (stm, stms) => trStmt(env, stm)@stms) [] stms
641            end            end

Legend:
Removed from v.2837  
changed lines
  Added in v.2838

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