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

SCM Repository

[diderot] Annotation of /branches/charisee/src/compiler/mid-to-low/vec-to-low-set.sml
ViewVC logotype

Annotation of /branches/charisee/src/compiler/mid-to-low/vec-to-low-set.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3633 - (view) (download)

1 : jhr 3624 (* vec-to-low-set.sml
2 :     *
3 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     *
5 :     * COPYRIGHT (c) 2016 The University of Chicago
6 :     * All rights reserved.
7 :     *)
8 :    
9 :     (*
10 : cchiw 3444 * helper functions used for vector operations.
11 :     * At this point every index is bound to an int
12 :     * and we are ready to return low-IL code.
13 : cchiw 3602 * using LowIL vectors ops like subVec, addVec, prodVec..
14 : cchiw 3444 *
15 :     * EIN->scan->iter->here.
16 : cchiw 3553 *)
17 : cchiw 3602 structure VecToLow = struct
18 : cchiw 3444 local
19 :    
20 : cchiw 3602 structure Ty = LowILTypes
21 :     structure Op = LowOps
22 : cchiw 3444 structure E = Ein
23 : cchiw 3602 structure H = Helper
24 :     structure IMap = IntRedBlackMap
25 :    
26 : cchiw 3444 in
27 :    
28 : cchiw 3633
29 :     (*
30 :     * Each EIN operator has a list of arguments.
31 :     * To reduce code size each argument is grouped together with its index binding (ix), low-il variable (var_a),
32 :     * argument type(argTy), and operation type (opTy) in a datatype called paramTy.
33 :     * ParamTy =(id,a,argTy,ix, opTy).
34 :     *
35 :     * The EIN operator λA<A_ijk>_{ijk} (a)
36 :     * has a single argument a.
37 :     * It's paramTy is (id,a,argTy,ix, opTy) where id=0 and argTy=Ty.TensorTy[i,j,k]
38 :     *
39 :     * The opTy or operation type determines if second order tensor argument A
40 :     * will be treated as a scalar or vector arguement in the next operation.
41 :     * If opTy=Proj k then then last index is projected to a vector tensor[k] result= A[i,j,:]
42 :     * If opTy=Ind then each index in the the Tensor is indexed. real result= A[i,j,k]
43 :     *
44 :     *
45 :     * ParamTy(id,a,argTy,[i,j], opTy) where opTy= Proj(k) creates a vector
46 :     * => Op.ProjectLast (0,k ixx,Ty.TensorTy[i,j,k])
47 :     * A[i,j,:]
48 :     *
49 :     * ParamTy (id,a,argTy,[i,j,k],opTy) where opTy= Indx creates a scalar
50 :     * => Op.IndexTensor (0, ixx, Ty.TensorTy[i,j,k])
51 :     * A[i,j,:]
52 :     *
53 :     * Vector operations(Op.AddVec, Op.SubVec, Op.ProdVec) expects 2 vector arguements and
54 :     * Vector operations (Op.scaVec) expects 1 scalar and 1 vector argument.
55 :     *)
56 :    
57 :    
58 : cchiw 3602 datatype opTy= Indx| Proj of int
59 :     datatype paramTy (*param id, argument var * argument type* ein binding* result type*)
60 :     = Param of int * LowIL.var * Ty.ty * E.mu list * opTy
61 :    
62 :     fun mapIndex e = H.mapIndex e
63 :     fun getTensorTy e = H.getTensorTy e
64 :     fun assignOP e = H.assignOP e
65 : cchiw 3553 fun indexTensor e = H.indexTensor e
66 :     fun mkProdVec e = H.mkProdVec e
67 :     fun mkSumVec e = H.mkSumVec e
68 :     fun mkMultiple e = H.mkMultiple e
69 : cchiw 3602 fun insert (k, v) d = IMap.insert (d, k, v)
70 :     fun iToss e = String.concat (List.map Int.toString e)
71 : cchiw 3444
72 : cchiw 3633
73 :     (*paramToOp: converts each parameter to low-ir operator*)
74 : cchiw 3602 fun paramToOp(avail, mapp, paramTy)= case paramTy
75 :     of Param(_, vA ,_ , [], Proj _) => (avail,vA)
76 :     | Param(_, vA, Ty.TensorTy[], _, Indx) => (avail, vA)
77 :     | Param(id,vA ,argTy, ix, opType) => let
78 : cchiw 3633 (* binds each index in ix using mapp*)
79 : cchiw 3602 val ixx = (List.map (fn (e1) => mapIndex (e1, mapp)) ix) (*index Ty*)
80 :     val str=String.concat (List.map Int.toString ixx)
81 : cchiw 3633 (*create low-ir operator *)
82 : cchiw 3602 val (ty,opp,name)= (case opType
83 :     of (Proj vecIX) => let
84 :     val vecTy = Ty.TensorTy [vecIX]
85 :     val opp = Op.ProjectLast (id, vecIX, ixx, argTy)
86 :     val name = String.concat["ProjLast_", str, "_"]
87 :     in (vecTy,opp,name) end
88 :     | Indx => let
89 :     val opp = Op.IndexTensor (id, ixx, argTy)
90 :     val name = String.concat["Indx_",str, "_"]
91 :     in (Ty.TensorTy[], opp, name) end
92 :     (* end case *))
93 : cchiw 3444 in
94 : cchiw 3602 assignOP (avail, opp, [vA], name, ty)
95 : cchiw 3444 end
96 : cchiw 3602 (*--------------------Vectorization Helper Functions--------------------*)
97 :     fun negV (avail, mapp, (vA, vecIX, vec)) = let
98 :     val (avail, vB) = paramToOp (avail, mapp, vec)
99 : cchiw 3542 in
100 : cchiw 3602 assignOP (avail, Op.prodScaV vecIX, [vA, vB], "prodScaV", Ty.TensorTy [vecIX])
101 : cchiw 3542 end
102 : cchiw 3602 fun op2 (avail, mapp, (vecIX, dstop, vecA,vecB)) = let
103 :     val (avail, vA) = paramToOp (avail, mapp, vecA)
104 :     val (avail, vB) = paramToOp (avail, mapp, vecB)
105 : cchiw 3542 in
106 : cchiw 3602 assignOP (avail, dstop, [vA, vB], "vectorOp", Ty.TensorTy [vecIX])
107 : cchiw 3542 end
108 : cchiw 3602 fun addV (avail, mapp, (vecIX, rest)) = let
109 :     fun add (avail, [], rest) = (avail, List.rev rest)
110 :     | add (avail, vecT ::es, rest) = let
111 :     val (avail, vT) = paramToOp (avail, mapp, vecT)
112 : cchiw 3444 in
113 : cchiw 3602 add (avail, es, vT::rest)
114 : cchiw 3444 end
115 : cchiw 3602 val (avail, rest) = add (avail, rest, [])
116 : cchiw 3444 in
117 : cchiw 3602 mkMultiple (avail, rest, Op.addVec vecIX, Ty.TensorTy [vecIX])
118 : cchiw 3444 end
119 : cchiw 3602 (*dot product*)
120 :     fun dotV (avail, mapp, (vecIX, vecA, vecB)) = let
121 :     val (avail, vD) = op2 (avail, mapp, (vecIX, Op.prodVec vecIX, vecA, vecB))
122 : cchiw 3444 in
123 : cchiw 3602 mkSumVec (avail, vecIX, [vD])
124 : cchiw 3444 end
125 : cchiw 3602 (*Sum of dot Product*)
126 :     fun sumDotV (avail, mapp, ((E.V v, lb, ub), vecIX, vecA,vecB)) = let
127 :     val nextfnargs = (vecIX, vecA, vecB)
128 :     fun sumI (avail, counter, 0, rest) = let
129 :     val mapp = insert (v, 0) counter
130 :     val (avail, vE) = dotV (avail, mapp, nextfnargs)
131 : cchiw 3444 in
132 : cchiw 3602 mkMultiple (avail, vE::rest, Op.addSca, Ty.TensorTy [])
133 : cchiw 3444 end
134 : cchiw 3602 | sumI (avail, counter, sx, rest) = let
135 :     val mapp = insert (v, (sx+lb)) counter
136 :     val (avail, vE) = dotV (avail, mapp, nextfnargs)
137 : cchiw 3444 in
138 : cchiw 3602 sumI (avail, counter, sx-1, vE::rest)
139 : cchiw 3444 end
140 :     in
141 : cchiw 3602 sumI (avail, mapp, (ub-lb), [])
142 : cchiw 3444 end
143 : cchiw 3602 | sumDotV _ = raise Fail "Non-variable index in summation"
144 : cchiw 3444
145 :     end
146 :    
147 :     end

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