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 2826, Mon Nov 10 21:06:46 2014 UTC revision 2827, Tue Nov 11 00:18:38 2014 UTC
# Line 83  Line 83 
83              | Ty.TensorTy t =>CL.mkRealArr(N.tprog ,t)              | Ty.TensorTy t =>CL.mkRealArr(N.tprog ,t)
84              | Ty.SeqTy(Ty.IntTy, n) => CL.T_Named(N.ivecTy n)              | Ty.SeqTy(Ty.IntTy, n) => CL.T_Named(N.ivecTy n)
85              | Ty.SeqTy(ty, n) => CL.T_Array(trType ty, SOME n)              | Ty.SeqTy(ty, n) => CL.T_Array(trType ty, SOME n)
86              | Ty.AddrTy(ImageInfo.ImgInfo{ty=(_, rTy), ...}) => CL.T_Ptr(CL.T_Num rTy)              | Ty.AddrTy(ImageInfo.ImgInfo{ty=(_, rTy), ...}) =>
87                    CL.T_Ptr(CL.T_Num rTy)
88              | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) => CL.T_Ptr(CL.T_Named(N.imageTy dim))              | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) => CL.T_Ptr(CL.T_Named(N.imageTy dim))
89              | Ty.unionTy n => CL.T_Named(N.unionTy n )              | Ty.unionTy n => CL.T_Named(N.unionTy n )
90    
# Line 99  Line 100 
100          | _ => trType ty          | _ => trType ty
101          (* end case *))          (* end case *))
102    
   
   
   
   
103    (* generate new variables *)    (* generate new variables *)
104      local      local
105        val count = ref 0        val count = ref 0
# Line 157  Line 154 
154      (*prnt arrays *)      (*prnt arrays *)
155      fun prntArr(v,ix)= CL.mkSubscript(v, intExp ix)      fun prntArr(v,ix)= CL.mkSubscript(v, intExp ix)
156    
     (*prnt Matrix*)  
     (*v[indexAtY,indexAtX]::Ty[argTyY,argTyX]*)  
     fun prntMat(v,indexAtY,indexAtX,argTyY, argTyX)=let  
         val ix=argTyX* indexAtY+indexAtX  
     in  
         CL.mkSubscript(v, intExp ix)  
     end  
   
157    
158    
159    (* matrix indexing *)    (* matrix indexing *)
# Line 173  Line 162 
162    
163          CL.mkSubscript(CL.mkSubscript(m, ix), jx)          CL.mkSubscript(CL.mkSubscript(m, ix), jx)
164    
   
     fun matProj(m, ix) =  
      CL.mkSelect(CL.mkSubscript(m, ix), "r")  
   
   
   
165    (* Translate a TreeIL operator application to a CLang expression *)    (* Translate a TreeIL operator application to a CLang expression *)
166      fun trOp (rator, args) = (case (rator, args)      fun trOp (rator, args) = (case (rator, args)
167             of (Op.IAdd , [a, b]) => CL.mkBinOp(a, CL.#+, b)             of (Op.IAdd , [a, b]) => CL.mkBinOp(a, CL.#+, b)
# Line 194  Line 177 
177              | (Op.addVec _,[a,b])    => CL.mkBinOp(a, CL.#+, b)              | (Op.addVec _,[a,b])    => CL.mkBinOp(a, CL.#+, b)
178              | (Op.prodVec _,[a, b])  => CL.mkBinOp(a, CL.#*, b)              | (Op.prodVec _,[a, b])  => CL.mkBinOp(a, CL.#*, b)
179              | (Op.Sqrt ,[a])         =>       CL.E_Sqrt a              | (Op.Sqrt ,[a])         =>       CL.E_Sqrt a
   
180               (*Vector functions*)               (*Vector functions*)
181              | (Op.prodScaV d,args)   => CL.E_Apply(N.NameScaV d, args)              | (Op.prodScaV d,args)   => CL.E_Apply(N.NameScaV d, args)
182              | (Op.sumVec (nSize,oSize),args)     => CL.E_Apply(N.NameSumV oSize, args)              | (Op.sumVec (nSize,oSize),args)     => CL.E_Apply(N.NameSumV oSize, args)
183              | (Op.dotVec d,args)     => CL.E_Apply(N.NameDotV d, args)              | (Op.dotVec d,args)     => CL.E_Apply(N.NameDotV d, args)
184                        (*Index Tensor*)
185                | (Op.IndexTensor(true,i,n),[a])=> vecIndex (a,n,i) (*cast from vector*)
186                      (*INDEX A VECTOR->SCALAR *)              | (Op.IndexTensor(false,i,n),[a])=> prntArr(a,i) (*arg as an array*)
             | (Op.IndexTensor(_,Ty.indexTy [i],  Ty.TensorTy [n]),[a])  
                 => prntArr(a,i)(* vecIndex (a,n,i)*)  
             | (Op.IndexTensor(_,Ty.indexTy [i],  Ty.SeqTy _),[a])  
                 => prntArr(a,i)  
   
                    (*INDEX A MATRIX ->SCALAR*)  
             | (Op.IndexTensor (_,Ty.indexTy [i,j], Ty.TensorTy[argTyY,argTyX]),[m])  
                 =>prntMat(m,i,j,argTyY, argTyX)  
             | (Op.IndexTensor (_, Ty.indexTy indexAt, argTy),args)=>  raise Fail"higer tensor "  
   
   
                 (*INDEX A MATRIX-> VECTOR*)  
             (* Is now removed at the Low-Tree-IL Stage*)  
             | (Op.ProjectTensor (rstTy ,j ),args)  =>  
                 CL.E_Apply(N.NameProj rstTy , args@[CL.mkInt (IntInf.fromInt j)])  
   
187    
188                  (*Image related operators*)                  (*Image related operators*)
189               | (Op.baseAddr(ImageInfo.ImgInfo{ty=(_,rTy), ...}) ,[a])=> let               | (Op.baseAddr(ImageInfo.ImgInfo{ty=(_,rTy), ...}) ,[a])=>
190                  val cTy = CL.T_Ptr(CL.T_Num rTy)                  CL.E_Cast(CL.T_Ptr(CL.T_Num rTy),CL.mkIndirect(a, "data"))
                 in  
                     CL.mkCast(cTy, CL.mkIndirect(a, "data"))  
                 end  
191              | (Op.baseAddr _,_)=> CL.mkBinOp(CL.E_Str"baseString", CL.#-, CL.E_Str"none")              | (Op.baseAddr _,_)=> CL.mkBinOp(CL.E_Str"baseString", CL.#-, CL.E_Str"none")
192              | (Op.imgAddr(Vinfo,indexAtTy, dim), [base,a,b])=>              | (Op.imgAddr(Vinfo,indexAtTy, dim), [base,a,b])=>
193    
194                  CL.mkBinOp(base, CL.#+, CL.mkBinOp(b, CL.#+,  CL.mkBinOp(CL.mkInt 77, CL.#*, a)))                  CL.mkBinOp(base, CL.#+, CL.mkBinOp(b, CL.#+,  CL.mkBinOp(CL.mkInt 77, CL.#*, a)))
195              | (Op.Transform(_,i),[a]) => CL.mkIndirect(a, "w2i["^(Int.toString i)^"].v")
196              | (Op.imgLoad(Vinfo ,dim, nlength),[addr])=>              | (Op.Translate(ImageInfo.ImgInfo{ty=(_,rTy), ...}),[a])=>CL.mkIndirect(a, "tVec")
   
 (*CL.E_Indirect (addr,"shoud load image")*)  
 let  
                 val realTy as CL.T_Num rTy = !N.gRealTy  
                 val a = CL.E_UnOp(CL.%*, addr)  
                 in  
                     (*if (rTy = ImageInfo.sampleTy Vinfo)  
                     then a  
                     else CL.E_Cast(realTy, addr)*) a  
                 end  
   
             | (Op.Transform(ImageInfo.ImgInfo{ty=(_,rTy), ...}),[a])=> let  
   
 val cTy = CL.T_Ptr(CL.T_Num rTy)  
 in  
 (*CL.mkCast(cTy, *)(CL.mkIndirect(a, "w2i"))  
 end  
             | (Op.Translate(ImageInfo.ImgInfo{ty=(_,rTy), ...}),[a])=> (* "Vinfo-Translate"*)  
 let  
   
 val cTy = CL.T_Ptr(CL.T_Num rTy)  
 in  
 CL.mkCast(cTy, CL.mkIndirect(a, "tVec"))  
 end  
   
   
   
197              | (Op.Abs(Ty.IntTy), args) => CL.mkApply("abs", args)              | (Op.Abs(Ty.IntTy), args) => CL.mkApply("abs", args)
198              | (Op.Abs(Ty.TensorTy[]), args) => CL.mkApply(N.fabs(), args)              | (Op.Abs(Ty.TensorTy[]), args) => CL.mkApply(N.fabs(), args)
199              | (Op.Abs ty, [a]) => raise Fail(concat["Abs<", Ty.toString ty, ">"])              | (Op.Abs ty, [a]) => raise Fail(concat["Abs<", Ty.toString ty, ">"])
# Line 309  Line 245 
245              | (Op.RealToInt d, args) => CL.mkApply(N.vecftoi d, args)              | (Op.RealToInt d, args) => CL.mkApply(N.vecftoi d, args)
246  (* FIXME: need type info *)  (* FIXME: need type info *)
247    
248                      (*Replaced with baseAddr operator                      (*Replaced with baseAddr operator*)
249              | (Op.ImageAddress(ImageInfo.ImgInfo{ty=(_,rTy), ...}), [a]) => let              | (Op.ImageAddress(ImageInfo.ImgInfo{ty=(_,rTy), ...}), [a]) =>  CL.mkIndirect(a, "data")
                 val cTy = CL.T_Ptr(CL.T_Num rTy)  
                 in  
                   CL.mkCast(cTy, CL.mkIndirect(a, "data"))  
                 end  
                     *)  
250              | (Op.LoadVoxels(info, 1), [a]) => let              | (Op.LoadVoxels(info, 1), [a]) => let
251                  val realTy as CL.T_Num rTy = !N.gRealTy                  val realTy as CL.T_Num rTy = !N.gRealTy
252                  val a = CL.E_UnOp(CL.%*, a)                  val a = CL.E_UnOp(CL.%*, a)
# Line 327  Line 258 
258              | (Op.LoadVoxels _, [a]) =>              | (Op.LoadVoxels _, [a]) =>
259                  raise Fail("impossible " ^ Op.toString rator)                  raise Fail("impossible " ^ Op.toString rator)
260    
   
   
   
   
261              | (Op.Inside(ImageInfo.ImgInfo{dim, ...}, s), [pos, img]) =>              | (Op.Inside(ImageInfo.ImgInfo{dim, ...}, s), [pos, img]) =>
262                  CL.mkApply(N.inside dim, [pos, img, intExp s])                  CL.mkApply(N.inside dim, [pos, img, intExp s])
263              | (Op.Input(ty, desc, name), []) =>              | (Op.Input(ty, desc, name), []) =>
# Line 356  Line 283 
283                      CL.mkApply(N.NameLdArr(aligned,n,orig), trExps(env, [v,arg]))                      CL.mkApply(N.NameLdArr(aligned,n,orig), trExps(env, [v,arg]))
284                      | IL.E_Mux (_,_,_,_,[a1]) => trExp(env,a1)                      | IL.E_Mux (_,_,_,_,[a1]) => trExp(env,a1)
285    
286              | IL.E_Mux (_,_,_,_,args) => (*raise Fail "Mux in tree-il stage"*)              | IL.E_Mux (_,_,_,_,args) => (*raise Fail "Mux in tree-il stage, try trExp()"*)
287                      CL.mkApply(N.NameMux, trExps(env, args))                      CL.mkApply(N.NameMux, trExps(env, args))
288               | IL.E_Holder (x,_) => CL.mkStr ("Holder for "^(V.name x))               | IL.E_Holder (x,_) => CL.mkStr ("Holder for "^(V.name x))
289                      (*VarToC.rvalueVar (env, x)*)                      (*VarToC.rvalueVar (env, x)*)
   
290            (* end case *))            (* end case *))
291      and trExps (env, exps) = List.map (fn exp => trExp(env, exp)) exps      and trExps (env, exps) = List.map (fn exp => trExp(env, exp)) exps
292    
293    
294      fun storeVec(env,x',A, isFill, oSize,ty,pieces,args)=let      fun storeVec(env,x',offset,A, isFill, oSize,ty,pieces,args)=let
295    
296          fun dumpStore ([])=[]          fun dumpStore ([])=[]
297            | dumpStore (Dst.E_Mux(_,_,_,_,ops)::es)=ops@dumpStore es            | dumpStore (Dst.E_Mux(_,_,_,_,ops)::es)=ops@dumpStore es
# Line 377  Line 303 
303                  fun sort([],_,_)=[]                  fun sort([],_,_)=[]
304                  | sort(nSize::ps,e::es,offset)= [CL.mkApply(N.NameMkVec(A,nSize,oSize),                  | sort(nSize::ps,e::es,offset)= [CL.mkApply(N.NameMkVec(A,nSize,oSize),
305                      [x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]  @ sort(ps, es,offset + IntInf.fromInt oSize)                      [x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]  @ sort(ps, es,offset + IntInf.fromInt oSize)
306              in sort(pieces,args',0) end              in sort(pieces,args',IntInf.fromInt offset) end
307              else let              else let
308                  fun sort([],_,_)=[]                  fun sort([],_,_)=[]
309                  | sort(nSize::ps,e::es,offset)= [CL.mkApply(N.NameMkVec(A,nSize,oSize),                  | sort(nSize::ps,e::es,offset)= [CL.mkApply(N.NameMkVec(A,nSize,oSize),
310                      [x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]  @ sort(ps, es,offset + IntInf.fromInt nSize)                      [x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]  @ sort(ps, es,offset + IntInf.fromInt nSize)
311              in sort(pieces,args',0) end              in sort(pieces,args', IntInf.fromInt offset) end
312          in          in
313              List.map (fn e=> CL.S_Exp e ) exp              List.map (fn e=> CL.S_Exp e ) exp
314          end          end
# Line 527  Line 453 
453                        [CL.mkCall(N.zeroVec(n), [lhs])]                        [CL.mkCall(N.zeroVec(n), [lhs])]
454              | IL.E_Op(Op.Zero(Ty.TensorTy[m,n]), args) =>              | IL.E_Op(Op.Zero(Ty.TensorTy[m,n]), args) =>
455                  [CL.mkCall(N.zeroMat(m,n), [lhs])]                  [CL.mkCall(N.zeroMat(m,n), [lhs])]
456            (*  | IL.E_Op(Op.LoadVoxels(info, n), [a]) =>*)               (*Op.imgLoad(info ,dim, n),[a])=>
               | IL.E_Op(Op.imgLoad(info ,dim, n),[a])=>  
457                  if (n > 1)                  if (n > 1)
458                    then let                    then let
459                      val stride = ImageInfo.stride info                      val stride = ImageInfo.stride info
# Line 543  Line 468 
468    
469                      in [                      in [
470                        CL.mkDecl(CL.T_Ptr(CL.T_Num rTy), vp, SOME(CL.I_Exp(trExp(env, a)))),                        CL.mkDecl(CL.T_Ptr(CL.T_Num rTy), vp, SOME(CL.I_Exp(trExp(env, a)))),
471                        (* CL.mkAssign(lhs,*)                          CL.mkAssign(lhs,CL.mkApply(N.NameConsVec n, List.tabulate (n, mkLoad)))
472                           CL.S_Exp(CL.mkApply(N.NameConsArray n, [lhs]@ List.tabulate (n, mkLoad)))  
473                      ] end                      ] end
474                          else   [CL.mkAssign(lhs, trExp(env, rhs))]                          else   [CL.mkAssign(lhs, trExp(env, rhs))]
475                            *)
476              | IL.E_Var x => (case IL.Var.ty x              | IL.E_Var x => (case IL.Var.ty x
477                   of Ty.TensorTy[n,m] => [CL.mkCall(N.copyMat(n,m), [lhs, VarToC.rvalueVar(env, x)])]                   of Ty.TensorTy[n,m] => [CL.mkCall(N.copyMat(n,m), [lhs, VarToC.rvalueVar(env, x)])]
478                    | _ => [CL.mkAssign(lhs, VarToC.rvalueVar(env, x))]                    | _ => [CL.mkAssign(lhs, VarToC.rvalueVar(env, x))]
# Line 609  Line 535 
535    
536      fun trStms (env, stms,isVecTy) = let      fun trStms (env, stms,isVecTy) = let
537    
538            fun getVar v=  (case v
539                of IL.E_Var x   => VarToC.lvalueVar (env, x)
540                | IL.E_State x  => VarToC.lvalueStateVar x
541                | _             => raise Fail "NonVar in exp"
542            (*end case *))
543    
544              fun trStmt (env, stm) = (case stm              fun trStmt (env, stm) = (case stm
545                   of IL.S_Comment text => [CL.mkComment text]                   of IL.S_Comment text => [CL.mkComment text]
546                    | IL.S_Assign([x], exp) =>                    | IL.S_Assign([x], exp) =>
# Line 619  Line 551 
551                          trBlk(env, thenBlk,isVecTy),                          trBlk(env, thenBlk,isVecTy),
552                          trBlk(env, elseBlk,isVecTy))]                          trBlk(env, elseBlk,isVecTy))]
553                    | IL.S_New _ => raise Fail "new not supported yet" (* FIXME *)                    | IL.S_New _ => raise Fail "new not supported yet" (* FIXME *)
554                      | IL.S_Copy(x,exp,offset,n)=>
555                    | IL.S_Copy([x],exp,n)=>                          [CL.S_Exp (CL.mkApply(N.NameCopyTensor [n],[getVar x,trExp(env,exp),CL.mkIntTy(IntInf.fromInt offset, !N.gIntTy)]))]
                         [CL.S_Exp (CL.mkApply(N.NameCopyTensor [n],[VarToC.lvalueStateVar x,trExp(env,exp)]))]  
556                    | IL.S_Save([x],exp as IL.E_Var v)=>( case (V.kind v,V.rTy v)                    | IL.S_Save([x],exp as IL.E_Var v)=>( case (V.kind v,V.rTy v)
557                      of (IL.VK_Global,Ty.TensorTy [n]) => let                      of (IL.VK_Global,Ty.TensorTy [n]) => let
558                          val expS=  CL.mkApply(N.NameCopyTensor [n] ,                          val expS=  CL.mkApply(N.NameCopyTensor [n] ,
# Line 667  Line 598 
598                    | IL.S_Active => [CL.mkReturn(SOME(CL.mkVar N.kActive))]                    | IL.S_Active => [CL.mkReturn(SOME(CL.mkVar N.kActive))]
599                    | IL.S_Stabilize => [CL.mkReturn(SOME(CL.mkVar N.kStabilize))]                    | IL.S_Stabilize => [CL.mkReturn(SOME(CL.mkVar N.kStabilize))]
600                    | IL.S_Die => [CL.mkReturn(SOME(CL.mkVar N.kDie))]                    | IL.S_Die => [CL.mkReturn(SOME(CL.mkVar N.kDie))]
601                    | IL.S_StoreVec(v,A, isFill, orig, ty,Ty.vectorLength pieces,args)=>let                    | IL.S_StoreVec(v,offset,A, isFill, orig, ty,Ty.vectorLength pieces,args)=>let
                     val v'=(case v  
                         of IL.E_Var x=>VarToC.lvalueVar (env, x)  
                         | IL.E_State x =>VarToC.lvalueStateVar (x)  
                         |_ => raise Fail "nonvar in storeVec"  
                         (*end case *))  
602                      in                      in
603                          storeVec(env,v',A, isFill,orig,ty,pieces,args)                          storeVec(env,getVar v,offset,A, isFill,orig,ty,pieces,args)
604                      end                      end
605                    | 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)))]
606    

Legend:
Removed from v.2826  
changed lines
  Added in v.2827

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