Home My Page Projects Code Snippets Project Openings diderot

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/mid-to-low/ein-to-low.sml
 [diderot] / branches / vis15 / src / compiler / mid-to-low / ein-to-low.sml

Diff of /branches/vis15/src/compiler/mid-to-low/ein-to-low.sml

revision 3628, Sun Jan 31 14:30:06 2016 UTC revision 3632, Sun Jan 31 17:45:58 2016 UTC
# Line 13  Line 13
13  * i.e. <A_ij+B_ij>_ij vs.<A_ji+B_ij>_ij  * i.e. <A_ij+B_ij>_ij vs.<A_ji+B_ij>_ij
14  *  *
15  *     (1) If indices match then passes to Iter->VecToLow functions.  *     (1) If indices match then passes to Iter->VecToLow functions.
16  *            Creates LowIL vector operators.  *            Creates LowIR vector operators.
17  *     (2) Iter->ScaToLow  *     (2) Iter->ScaToLow
18  *           Creates Low-IL scalar operators  *           Creates Low-IL scalar operators
19  * Note. The Iter function creates LowIL.CONS and therefore binds the indices in the EIN.body  * Note. The Iter function creates LowIR.CONS and therefore binds the indices in the EIN.body
20  *)  *)
21
22  structure EinToLow : sig  structure EinToLow : sig
23
24      val expand : LowIL.var * Ein.ein * LowIL.var list -> LowIL.assign list      val expand : LowIR.var * Ein.ein * LowIR.var list -> LowIR.assignment list
25
26    end = struct    end = struct
27
28      structure Var = LowIL.Var      structure Var = LowIR.Var
29      structure E = Ein      structure E = Ein
structure Iter = Iter
structure EtoSca = ScaToLow
structure EtoVec = VecToLow
30      structure H = Helper      structure H = Helper
31      structure Op = LowOps      structure Op = LowOps
32
# Line 72  Line 69
69              (* end case *)              (* end case *)
70            end            end
71
72      (*runGeneralCase:Var*E.EIN*Var-> Var*LowIL.ASSN list      (*runGeneralCase:Var*E.EIN*Var-> Var*LowIR.ASSN list
73      * does not do vector projections      * does not do vector projections
74      * instead approach like a general EIN      * instead approach like a general EIN
75      *)      *)
76      fun runGeneralCase (e:Ein.ein, args:LowIL.var list) = let      fun runGeneralCase (index, args:LowIR.var list) =
77            val index = Ein.index e            iter (AvailRHS.new(), index, index, ScaToLow.generalfn, e, args)
in
iter (AvailRHS.new(), index, index, EtoSca.generalfn, e, args)
end
78
79      fun createP((E.EIN{params ,...}, args), vecIndex, id, ix) =      fun createP (params, args, vecIndex, id, ix) =
80          VecToLow.Param(id, List.nth (args, id), H.getTensorTy (params, id), ix, VecToLow.Proj vecIndex)          VecToLow.Param(id, List.nth (args, id), H.getTensorTy (params, id), ix, VecToLow.Proj vecIndex)
81
82      fun createI((E.EIN{params ,...}, args), id, ix) =      fun createI (params, args, id, ix) =
83          VecToLow.Param(id, List.nth (args, id), H.getTensorTy (params, id), ix, VecToLow.Indx)          VecToLow.Param(id, List.nth (args, id), H.getTensorTy (params, id), ix, VecToLow.Indx)
84
85      (*handleNeg:.body* int list*info ->Var*LowIL.ASSN list      (*handleAdd:E.body*int list*info ->Var*LowIR.ASSN list
* info:(string*E.EIN*Var list)
* low-IL code for scaling a vector with negative 1.
*)
fun handleNeg (E.Op1(E.Neg, E.Tensor(id , alpha)), index, info) = let
val (n, vecIX, index') = dropIndex index
in case (matchLast(alpha, n))
of SOME ix1 => let
val avail = AvailRHS.new()
val (avail, vA) = intToReal(avail, ~1)
val vecB = createP(info, vecIX, id, ix1)
val nextfnargs = (vA, vecIX, vecB)
in
iter(avail, index, index', EtoVec.negV, nextfnargs)
end
| NONE => runGeneralCase info
end

(*handleSub:E.body*int list*info ->Var*LowIL.ASSN list
* info:(string*E.EIN*Var list)
* low-IL code for subtracting two vectors
*)
fun handleSub (E.Op2(E.Sub, E.Tensor(id1, alpha), E.Tensor(id2, beta)), index, info) = let
val (n, vecIX, index') = dropIndex index
in case(matchLast(alpha, n) , matchLast(beta, n)) of
(SOME ix1, SOME ix2) =>let
val avail = AvailRHS.new()
val vecA = createP(info, vecIX, id1, ix1)
val vecB = createP(info, vecIX, id2, ix2)
val nextfnargs = (vecIX, Op.subVec vecIX, vecA, vecB)
in
iter(avail, index, index', EtoVec.op2, nextfnargs)
end
| _   => runGeneralCase info
end

86      * info:(string*E.EIN*Var list)      * info:(string*E.EIN*Var list)
87      * low-IL code for adding two vectors      * low-IL code for adding two vectors
88      *)      *)
# Line 135  Line 93
93              val avail = AvailRHS.new()              val avail = AvailRHS.new()
94              val nextfnargs = (vecIX, List.rev rest)              val nextfnargs = (vecIX, List.rev rest)
95              in              in
97              end              end
98          | sample (E.Tensor(id1, alpha)::ts, rest) = (case (matchLast(alpha, n))          | sample (E.Tensor(id1, alpha)::ts, rest) = (case (matchLast(alpha, n))
99              of SOME ix1    => sample(ts, createP(info, vecIX, id1, ix1)::rest)              of SOME ix1    => sample(ts, createP(params, vecIX, id1, ix1)::rest)
100              | _            => runGeneralCase info              | _            => runGeneralCase info
101              (* end case *))              (* end case *))
102          | sample _ = runGeneralCase info          | sample _ = runGeneralCase info
# Line 146  Line 104
104              sample(es, [])              sample(es, [])
105          end          end
106
107      (*handleScale:E.tensor_id*E.tensor_id*E.alpha*int list*info ->Var*LowIL.ASSN list      (*handleScale:E.tensor_id*E.tensor_id*E.alpha*int list*info ->Var*LowIR.ASSN list
108      * info:(string*E.EIN*Var list)      * info:(string*E.EIN*Var list)
109      * low-IL code for adding scaling a vector      * low-IL code for adding scaling a vector
110      *)      *)
111      fun handleScale (id1, id2, alpha2, index, info) = let      fun handleScale (id1, id2, alpha2, params, index) = let
112          val (n, vecIX, index') = dropIndex index          val (n, vecIX, index') = dropIndex index
113          in case matchLast(alpha2, n)            in
114                case matchLast(alpha2, n)
115              of SOME ix2 =>  let              of SOME ix2 =>  let
116                  val avail = AvailRHS.new()                  val avail = AvailRHS.new()
117                  val vecA = createI(info, id1, [])                    val vecA = createI (params, args, id1, [])
118                  val vecB = createP(info, vecIX, id2, ix2)                    val vecB = createP (params, args, vecIX, id2, ix2)
119                  val nextfnargs = (vecIX, Op.prodScaV vecIX, vecA, vecB)                    val nextfnargs = (vecIX, Op.VScale vecIX, vecA, vecB)
120                  in                  in
121                      iter(avail, index, index', EtoVec.op2, nextfnargs)                      iter (avail, index, index', VecToLow.op2, nextfnargs)
122                  end                  end
123              | _ =>runGeneralCase info              | _ =>runGeneralCase info
124                (* end case *)
125          end          end
126
127      (*handleProd:E.body*int list*info ->Var*LowIL.ASSN list      (*handleProd:E.body*int list*info ->Var*LowIR.ASSN list
128      * info:(string*E.EIN*Var list)      * info:(string*E.EIN*Var list)
129      * low-IL code for vector product      * low-IL code for vector product
130      *)      *)
# Line 175  Line 135
135          in case(matchFindLast(alpha, n), matchFindLast(beta, n))          in case(matchFindLast(alpha, n), matchFindLast(beta, n))
136              of ((SOME ix1, NONE), (SOME ix2, NONE)) => let              of ((SOME ix1, NONE), (SOME ix2, NONE)) => let
137                  (*n is the last index of alpha, beta and nowhere else, possible modulate*)                  (*n is the last index of alpha, beta and nowhere else, possible modulate*)
138                  val vecA = createP(info, vecIX, id1, ix1)                  val vecA = createP(params, args, vecIX, id1, ix1)
139                  val vecB = createP(info, vecIX, id2, ix2)                  val vecB = createP(params, args, vecIX, id2, ix2)
140                  val nextfnargs = (vecIX, Op.prodVec vecIX, vecA, vecB)                  val nextfnargs = (vecIX, Op.VMul vecIX, vecA, vecB)
141                  in                  in
142                      iter(avail, index, index', EtoVec.op2, nextfnargs)                      iter(avail, index, index', VecToLow.op2, nextfnargs)
143                  end                  end
144              | ((NONE, NONE), (SOME ix2, NONE)) =>let              | ((NONE, NONE), (SOME ix2, NONE)) =>let
145                  (*n is the last index of beta and nowhere else, possible scaleVector*)                  (*n is the last index of beta and nowhere else, possible scaleVector*)
146                  val vecA = createI(info, id1, alpha)                  val vecA = createI(params, args, id1, alpha)
147                  val vecB = createP(info, vecIX, id2, ix2)                  val vecB = createP(params, args, vecIX, id2, ix2)
148                  val nextfnargs = (vecIX, Op.prodScaV vecIX, vecA, vecB)                  val nextfnargs = (vecIX, Op.VScale vecIX, vecA, vecB)
149                  in                  in
150                      iter(avail, index, index', EtoVec.op2 , nextfnargs)                      iter(avail, index, index', VecToLow.op2 , nextfnargs)
151                  end                  end
152              | ((SOME ix1, NONE), (NONE, NONE)) =>let              | ((SOME ix1, NONE), (NONE, NONE)) =>let
153                  (*n is the last index of alpha and nowhere else, ossile scaleVector*)                  (*n is the last index of alpha and nowhere else, ossile scaleVector*)
154                  val vecA = createI(info, id2, beta)                  val vecA = createI(params, args, id2, beta)
155                  val vecB = createP(info, vecIX, id1, ix1)                  val vecB = createP(params, args, vecIX, id1, ix1)
156                  val nextfnargs = (vecIX, Op.prodScaV vecIX, vecA, vecB)                  val nextfnargs = (vecIX, Op.VScale vecIX, vecA, vecB)
157
158                  in                  in
159                      iter(avail, index, index', EtoVec.op2, nextfnargs)                      iter(avail, index, index', VecToLow.op2, nextfnargs)
160                  end                  end
161              | _ => runGeneralCase info              | _ => runGeneralCase info
162          end          end
163
164      (*handleSumProd:E.body*int list*info ->Var*LowIL.ASSN list      (*handleSumProd:E.body*int list*info ->Var*LowIR.ASSN list
165      * info:(string*E.EIN*Var list)      * info:(string*E.EIN*Var list)
166      * low-IL code for dot product      * low-IL code for dot product
167      *)      *)
# Line 211  Line 171
171                  (*v is the last index of alpha, beta and nowhere else, possible sumProd*)                  (*v is the last index of alpha, beta and nowhere else, possible sumProd*)
172                  val avail = AvailRHS.new()                  val avail = AvailRHS.new()
173                  val vecIX= ub+1                  val vecIX= ub+1
174                  val vecA = createP(info, vecIX, id1, ix1)                  val vecA = createP(params, args, vecIX, id1, ix1)
175                  val vecB = createP(info, vecIX, id2, ix2)                  val vecB = createP(params, args, vecIX, id2, ix2)
176                  val nextfnargs = (vecIX, vecA, vecB)                  val nextfnargs = (vecIX, vecA, vecB)
177                  in                  in
178                      iter(avail, index, index, EtoVec.dotV, nextfnargs)                      iter(avail, index, index, VecToLow.dotV, nextfnargs)
179                  end                  end
180          | _ => runGeneralCase info          | _ => runGeneralCase info
181
182
183      (*handleSumProd:E.body*int list*info ->Var*LowIL.ASSN list      (*handleSumProd:E.body*int list*info ->Var*LowIR.ASSN list
184      * info:(string*E.EIN*Var list)      * info:(string*E.EIN*Var list)
185      * low-IL code for double dot product      * low-IL code for double dot product
186      * Sigma_{i, j} A_ij B_ij      * Sigma_{i, j} A_ij B_ij
# Line 236  Line 196
196                  val avail = AvailRHS.new()                  val avail = AvailRHS.new()
197                  (*val nextfnargs = (Ein.params e, args, sx, ub+1, id1, ix1, id2, ix2)*)                  (*val nextfnargs = (Ein.params e, args, sx, ub+1, id1, ix1, id2, ix2)*)
198                  val vecIX= ub+1                  val vecIX= ub+1
199                  val vecA = createP(info, vecIX, id1, ix1)                  val vecA = createP(params, args, vecIX, id1, ix1)
200                  val vecB = createP(info, vecIX, id2, ix2)                  val vecB = createP(params, args, vecIX, id2, ix2)
201                  val nextfnargs = (sx, vecIX, vecA, vecB)                  val nextfnargs = (sx, vecIX, vecA, vecB)
202                  in                  in
203                      SOME(iter(avail, index, index, EtoVec.sumDotV, nextfnargs))                      SOME(iter(avail, index, index, VecToLow.sumDotV, nextfnargs))
204                  end                  end
205              | _ => NONE              | _ => NONE
206              (* end case *))              (* end case *))
# Line 253  Line 213
213              (* end case *))              (* end case *))
214          end          end
215
216    (* scan:var*E.Ein*Var list * Var list-> Var*LowIL.Assgn list    (* scan:var*E.Ein*Var list * Var list-> Var*LowIR.Assgn list
217     * scans body  for vectorization potential     * scans body  for vectorization potential
218     *)     *)
219      fun expand (y, Ein.EIN{params, index, body}, args : LowIL.var list) = let      fun expand (y, Ein.EIN{params, index, body}, args : LowIR.var list) = let
220            val info = (e, args)            val info = (e, args)
221            val all = (b, index, info)            val all = (b, index, info)
222          (* any result type *)          (* any result type *)
# Line 269  Line 229
229                  (* end case *))                  (* end case *))
230          (* non scalar result for sure *)          (* non scalar result for sure *)
231            fun nonScalar () = (case body            fun nonScalar () = (case body
232                   of E.Op2(E.Sub, E.Tensor(_, _::_), E.Tensor(_, _::_)) =>                   of E.Op2(E.Sub, E.Tensor(id1, alpha as (_::_)), E.Tensor(id2, beta as (_::_))) => let
233                        handleSub all                        val (n, vecIX, index') = dropIndex index
234                          in
235                            case (matchLast(alpha, n), matchLast(beta, n))
236                             of (SOME ix1, SOME ix2) => let
237                                  val vecA = createP (params, args, vecIX, id1, ix1)
238                                  val vecB = createP (params, args, vecIX, id2, ix2)
239                                  val nextfnargs = (vecIX, Op.VSub vecIX, vecA, vecB)
240                                  in
241                                    iter (AvailRHS.new(), index, index', VecToLow.op2, nextfnargs)
242                                  end
243                              | _  => runGeneralCase (index, args)
244                            (* end case *)
245                          end
248                    | E.Op1(E.Neg, E.Tensor(_ , _::_)) =>                    | E.Op1(E.Neg, E.Tensor(id, alpha as (_::_))) => let
249                        handleNeg all                        val (n, vecIX, index') = dropIndex index
250                          in
251                            case matchLast (alpha, n)
252                             of SOME ix1 => let
253                                  val avail = AvailRHS.new()
254                                  val (avail, vA) = intToReal(avail, ~1)
255                                  val vecB = createP(params, args, vecIX, id, ix1)
256                                  val nextfnargs = (vA, vecIX, vecB)
257                                  in
258                                    iter (avail, index, index', VecToLow.negV, nextfnargs)
259                                  end
260                              | _ => runGeneralCase (index, args)
261                            (* end case *)
262                          end
263                    | E.Opn(E.Prod, [E.Tensor(s, []), E.Tensor(v, j::jx)]) =>                    | E.Opn(E.Prod, [E.Tensor(s, []), E.Tensor(v, j::jx)]) =>
264                        handleScale(s, v, j::jx, index, info)                        handleScale(s, v, j::jx, index, info)
265                    | E.Opn(E.Prod, [E.Tensor(v, j::jx), E.Tensor(s , [])]) =>                    | E.Opn(E.Prod, [E.Tensor(v, j::jx), E.Tensor(s , [])]) =>
# Line 285  Line 270
270                  (* end case *))                  (* end case *))
271  (* QUESTION: what is special about "3" here? *)  (* QUESTION: what is special about "3" here? *)
272            val (avail, _) = (case index            val (avail, _) = (case index
273                   of [3, 3] => runGeneralCase info                   of [3, 3] => runGeneralCase (index, args)
274                    | [3, 3, 3] => runGeneralCase info                    | [3, 3, 3] => runGeneralCase (index, args)
275                    | _::_ => nonScalar()                    | _::_ => nonScalar()
276                    | _ => gen()                    | _ => gen()
277                  (* end case *))                  (* end case *))
278            val (x, asgn):: rest = AvailRHS.getAssignments avail            val (x, asgn):: rest = AvailRHS.getAssignments avail
279            in            in
280              List.revMap LowIL.ASSGN ((y, A)::(x, A)::rest)              List.revMap LowIR.ASSGN ((y, A)::(x, A)::rest)
281            end            end
282
283      end      end

Legend:
 Removed from v.3628 changed lines Added in v.3632