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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/c-target/opr-to-clang.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/c-target/opr-to-clang.sml

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

revision 2794, Tue Nov 4 20:04:14 2014 UTC revision 2795, Tue Nov 4 21:58:11 2014 UTC
# Line 137  Line 137 
137      fun createDec(rtnType, fnName, params,blk)=   CL.D_Func([],rtnType,fnName,params,CL.S_Block blk)      fun createDec(rtnType, fnName, params,blk)=   CL.D_Func([],rtnType,fnName,params,CL.S_Block blk)
138    
139    
  (*Intermediate Statement from reals -> RealArray*)  
  fun IntermediateCons(d,VARS) =let  
     val ty=mkRealArr [d]  
     val tmpVar=CL.E_TyVar(ty,varA)  
     val stmt=CL.S_Eq(tmpVar,CL.E_Struct VARS)  
     in (varA, stmt)  
     end  
   
   
140   fun mkScaV d= let   fun mkScaV d= let
141      val rtnType= vecTy d      val rtnType= vecTy d
142      val fnName=N.NameScaV d      val fnName=N.NameScaV d
# Line 163  Line 154 
154    
155      (*SumVec functions *)      (*SumVec functions *)
156      (*Vec to Real*)      (*Vec to Real*)
157      fun mkSumV d= let      fun mkSumV(nSize,oSize)= let
158          val rtnType= realTy          val rtnType= realTy
159          val fnName=N.NameSumV d          val fnName=N.NameSumV oSize
160          val params=mkParams[ParamV d]          val params=mkParams[ParamV nSize]
161          val VarV=varToVar varV          val VarV=varToVar varV
162          val (e,VarUR)=mkExtVar(d, varU,VarV)          val (e,VarUR)=mkExtVar(nSize, varU,VarV)
163    
164          (*Return Expression *)          (*Return Expression *)
165          val indexedVec=indexDiderotType(VarUR,d)          val indexedVec=indexDiderotType(VarUR,oSize)
166          val rtn=mkRtn(mkAddM indexedVec)          val rtn=mkRtn(mkAddM indexedVec)
167          in          in
168              createDec(rtnType, fnName, params,[e,rtn])              createDec(rtnType, fnName, params,[e,rtn])
# Line 211  Line 202 
202              createDec(rtnType, fnName, params,[sum,rtn])              createDec(rtnType, fnName, params,[sum,rtn])
203          end          end
204    
205     (*
206          (*-------------- Dec functions from CONS ---------------*)      fun mkProj d= let
207            val fnName=N.NameProj d
208            val rtnType= vecTy d
209      fun ConsTensorToArray(ty,pieces)=let          val params=mkParams[ParamA,ParamI]
         val rtnType= voidTy  
         val fnName=N.NameConsArray ty  
210          val VarA= CL.E_Var varA          val VarA= CL.E_Var varA
211            val VarI = CL.E_Var varI
212          val _ =print ("found cons tensor to array"^Ty.toString (Ty.TensorTy ty))          val rhs= indexDiderotTypeWithOffset(VarA,d,VarI)
213          fun mkTenToArr(size,paramTy,rhs,vars)=let          val body'= mkCastStruct(rtnType,rhs)
214              val params=[mkParam ParamA]@ mkParamsSameType(paramTy, vars)          val rtn= mkRtn(CL.E_Ext(body'))
   
             val lhs=indexDiderotType(VarA, size)  
             val stmts=setEq(lhs,rhs)  
215          in          in
216              createDec(rtnType, fnName, params,stmts@[voidRtn])              createDec(rtnType, fnName, params,[rtn])
217          end          end
218         fun mkTenToArr2(size,paramTy,rhs,vars)=let   *)
         fun getVec([],_)=[]  
         | getVec(n::ns,v::vs)=[mkParam([],vecTy n,v)]@getVec(ns,vs)  
   
219    
220          val params=[mkParam ParamA]@getVec(pieces,vars)          (*-------------- Dec functions from CONS ---------------*)
221          val lhs=indexDiderotType(VarA, size)      fun realToArr n=let
222            val rtnType= voidTy
223            val fnName=N.NameConsArray n
224            val VarA= CL.E_Var varA
225            val vars=mkVar n
226            val rhs=varToVars vars
227            val params=[mkParam ParamA]@ mkParamsSameType(realTy, vars)
228            val lhs=indexDiderotType(VarA, n)
229          val stmts=setEq(lhs,rhs)          val stmts=setEq(lhs,rhs)
230          in          in
231              createDec(rtnType, fnName, params,stmts@[voidRtn])              createDec(rtnType, fnName, params,stmts@[voidRtn])
232          end          end
233    
234        fun realToVec d=let
         in (case ty  
             of  [d]=>let  
                 val vars=mkVar d  
                 val Vars=varToVars vars  
             in  
                 mkTenToArr(d,realTy,Vars,vars)  
             end  
             | [m,n]=>let  
                 val size=m*n  
                 (*Fix this *)  
                 val vars=mkVar size  
                 val Vars=varToVars vars  
                 val rhs=List.map (fn v => indexDiderotType(v, n)) Vars  
             in  
                 mkTenToArr2(size,star,flat rhs,vars)  
             end  
             | _=> default  
             (*end case*))  
         end  
   
   
   
     fun mkRealToVec d=let  
235          val rtnType= vecTy d          val rtnType= vecTy d
236          val fnName=N.NameConsVec d          val fnName=N.NameConsVec d
237          val vars=mkVar d          val vars=mkVar d
# Line 282  Line 249 
249    
250          (*-------------- Dec functions from LDVec ---------------*)          (*-------------- Dec functions from LDVec ---------------*)
251    
   
   
     (*Load for vectors *)  
     fun ldVec2(A,tyNew,tyOrig)= let  
         val VarA= CL.E_Var varA  
         val VarI=CL.E_Var varI  
         val rtnType= vecTy tyNew  
         val VarV= CL.E_Var varV  
         val ty=vecTy tyNew  
         val fnName=N.NameLdVec(A,tyNew,tyOrig)  
         val (stmt, VarUR)= mkExtVar(tyOrig, varA,VarV)  
   
   
         val body'= mkCastStruct(ty,indexDiderotTypeWithOffset(VarUR,tyNew,VarI))  
         val rtn= mkRtn(CL.E_Ext(body'))  
         val params=mkParams[ParamV tyOrig,ParamI]  
         in  
             createDec(rtnType, fnName, params,[stmt,rtn])  
         end  
   
   
252      (*Does Load when not aligned*)      (*Does Load when not aligned*)
253      (* val (e,VarUR)=mkExtVar(tyOrig, varU,VarA)*)      (* val (e,VarUR)=mkExtVar(tyOrig, varU,VarA)*)
254       fun ldVec(tyNew,tyOrig,rtnType,VarA,VarI) =let       fun ldVec(tyNew,tyOrig,rtnType,VarA,VarI) =let
# Line 321  Line 267 
267          [mkRtn (mkCastStruct(rtnType,pieces))]          [mkRtn (mkCastStruct(rtnType,pieces))]
268      end      end
269    
   
   
270      (*General Load*)      (*General Load*)
271      fun generalldVec(A,tyNew,tyOrig) =let      fun generalldVec(A,tyNew,tyOrig) =let
272          val VarA= CL.E_Var varA          val VarA= CL.E_Var varA
# Line 339  Line 283 
283      end      end
284    
285    
286            (*-------------- Dec functions from Store ---------------*)
         (*-------------- Dec functions from mKVec ---------------*)  
287  (* Aligned store vec body  (* Aligned store vec body
288   * (vec2f_t )&(A[4])=v;   * (vec2f_t )&(A[4])=v;
289   *   storeVec Aligned   *   storeVec Aligned
# Line 356  Line 299 
299   (*not aligned store Vec body *)   (*not aligned store Vec body *)
300   fun store(tyN,tyI,VarA,VarI,VarV)= let   fun store(tyN,tyI,VarA,VarI,VarV)= let
301      val (stmt, VarUR)= mkExtVar(tyN, varU,VarV)      val (stmt, VarUR)= mkExtVar(tyN, varU,VarV)
302      val x=tyI      val rhs= indexDiderotType(VarUR,tyI)
303      val rhs= indexDiderotType(VarUR,x)      val lhs=indexDiderotTypeWithOffset(VarA, tyI, VarI)
     val lhs=indexDiderotTypeWithOffset(VarA, x, VarI)  
304      val e=setEq(lhs,rhs)      val e=setEq(lhs,rhs)
305      in      in
306          [stmt]@e          [stmt]@e
307      end      end
308    
309    
  (*if tyN>tyO then store tyO indices  
    else store tyN indices  *)  
   
   
310   (*General store function *)   (*General store function *)
311   fun generalmkVec(aligned,tyN,tyOrig)= let   fun generalmkVec(aligned,tyOrig,tyN)= let
312      val rtnType = voidTy      val rtnType = voidTy
313      val fnName = N.NameMkVec(aligned,tyN,tyOrig)      val fnName = N.NameMkVec(aligned,tyN,tyOrig)
314      val VarA = CL.E_Var varA      val VarA = CL.E_Var varA
# Line 380  Line 318 
318      val params = mkParams [ParamA,ParamI,([],ty, varV)]      val params = mkParams [ParamA,ParamI,([],ty, varV)]
319    
320    
321      val stmts = (case (tyOrig>tyN,aligned)      val stmts = (case (tyN>tyOrig,aligned)
322          of (true,true) =>   storeAligned(tyN, ty, VarA,VarI,VarV)          of (false,true) =>   storeAligned(tyN, ty, VarA,VarI,VarV)
323          |  (true, _ )  => store(tyN,tyN,VarA,VarI,VarV)          |  (false, _ )  => store(tyN,tyN,VarA,VarI,VarV)
324          |  (false, _ )  => store(tyN,tyOrig,VarA,VarI,VarV)          |  (true, _ )  => store(tyN,tyOrig,VarA,VarI,VarV)
325          (*end case*))          (*end case*))
326      in      in
327          createDec(rtnType, fnName, params,stmts@[ voidRtn])          createDec(rtnType, fnName, params,stmts@[ voidRtn])
328      end      end
329             (*-------------- Dec functions from Store ---------------*)
330      fun mkCopy d= let      fun mkCopy d= let
331          val fnName=N.NameCopyTensor [d]          val fnName=N.NameCopyTensor [d]
332          val rtnType= voidTy          val rtnType= voidTy
# Line 401  Line 339 
339          in          in
340              createDec(rtnType, fnName, params,e)              createDec(rtnType, fnName, params,e)
341          end          end
     fun mkProj d= let  
         val fnName=N.NameProj d  
         val rtnType= vecTy d  
         val params=mkParams[ParamA,ParamI]  
         val VarA = CL.E_Var varA  
         val VarI = CL.E_Var varI  
         val rhs= indexDiderotTypeWithOffset(VarA,d,VarI)  
         val body'= mkCastStruct(rtnType,rhs)  
         val rtn= mkRtn(CL.E_Ext(body'))  
342    
         in  
             createDec(rtnType, fnName, params,[rtn])  
         end  
343    
344    
345      (* handleOPr: transform Tree-IL Opr to CLang Declarations*)      (* handleOPr: transform Tree-IL Opr to CLang Declarations*)
346      fun handleOpr(fnc,getPieces)=(case fnc      fun handleOpr(fnc,getPieces)=(case fnc
347          of ILF.LDArr (A,tyR,tyO,true)=>generalldVec(A,tyR,tyO)        of ILF.LDArr (A,tyR,tyO)=>generalldVec(A,tyR,tyO)
348          | ILF.LDArr (A,tyR,tyO,arr)=>ldVec2(A,tyR,tyO)        | ILF.STORE (A,tyO,tyNOp) => generalmkVec(A,tyO,tyNOp)
349          | ILF.STORE (A,tyR,tyO) => generalmkVec(A,tyR,tyO)        | ILF.CONSV n=> realToVec n
350        | ILF.CONSV n=> mkRealToVec n        |  ILF.CONS n=> realToArr n
       |  ILF.CONS( Ty.TensorTy [n])=> ConsTensorToArray ([n],getPieces n)  
          |  ILF.CONS( Ty.TensorTy [n,m])=> let  
             val p=getPieces m  
             fun getP(0,parts)=parts  
               | getP(c,parts)=getP(c-1,parts@p)  
   
             in  
                 ConsTensorToArray ( [n,m],getP(n,[]))  
             end  
   
       | ( ILF.CONS ty)=> (print ("found consTY but passed"^Ty.toString ty); default)  
351        |  (ILF.COPY n)=> mkCopy n        |  (ILF.COPY n)=> mkCopy n
352        |( ILF.OP(Op.prodScaV d))=> mkScaV d        | ILF.OP(Op.prodScaV d)=> mkScaV d
353        | ( ILF.OP(Op.sumVec d))=> mkSumV d        | ILF.OP(Op.sumVec(nSize,oSize)) => mkSumV(nSize,oSize)
354        | ( ILF.OP(Op.dotVec d))=> mkDotV d        | ( ILF.OP(Op.dotVec d))=> mkDotV d
355        | ( ILF.OP(Op.Floor d))=> mkFloorV d        | ( ILF.OP(Op.Floor d))=> mkFloorV d
356        | ILF.OP(Op.ProjectTensor(d,p))=> mkProj d        (*| ILF.OP(Op.ProjectTensor(d,p))=> mkProj d*)
357          | ( ILF.OP(Op.IndexTensor(a,b,c)))=> default
       | ( ILF.OP(Op.IndexTensor(a,RTy,b,c)))=> default  
358        | ( ILF.OP(Op.addVec _))=> default        | ( ILF.OP(Op.addVec _))=> default
359        | ( ILF.OP(Op.subVec _))=> default        | ( ILF.OP(Op.subVec _))=> default
360        | ( ILF.OP(Op.prodVec _))=> default        | ( ILF.OP(Op.prodVec _))=> default

Legend:
Removed from v.2794  
changed lines
  Added in v.2795

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