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

SCM Repository

[diderot] Annotation of /branches/vis15/src/compiler/ein/ein-util.sml
ViewVC logotype

Annotation of /branches/vis15/src/compiler/ein/ein-util.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 5574 - (view) (download)

1 : jhr 3516 (* ein-util.sml
2 :     *
3 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     *
5 :     * COPYRIGHT (c) 2015 The University of Chicago
6 :     * All rights reserved.
7 :     *)
8 :    
9 :     structure EinUtil : sig
10 :    
11 :     (* Are Ein functions/expressions the same? *)
12 :     val same : Ein.ein * Ein.ein -> bool
13 :     val sameExp : Ein.ein_exp * Ein.ein_exp -> bool
14 :    
15 :     (* compute a hash for an Ein function *)
16 :     val hash : Ein.ein -> Word.word
17 :    
18 : jhr 5574 val iterPP: Ein.ein_exp list -> Ein.ein_exp
19 :     val iterAA: Ein.ein_exp list -> Ein.ein_exp
20 :    
21 : jhr 3516 end = struct
22 :    
23 :     structure E = Ein
24 :    
25 :     fun sameExp (e1, e2) = let
26 :     fun sameIndex ([], []) = true
27 : jhr 4317 | sameIndex ((E.V i)::ix, (E.V j)::jx) = (i = j) andalso sameIndex (ix, jx)
28 :     | sameIndex ((E.C i)::ix, (E.C j)::jx) = (i = j) andalso sameIndex (ix, jx)
29 :     | sameIndex _ = false
30 : jhr 3516 fun sameKx ([], [])=true
31 : jhr 4317 | sameKx ((E.V i,_)::ix, (E.V j,_)::jx) = (i = j) andalso sameKx(ix, jx)
32 :     | sameKx ((E.C i,_)::ix, (E.C j,_)::jx) = (i = j) andalso sameKx(ix, jx)
33 :     | sameKx _ = false
34 : jhr 3516 fun sameSx ([], []) = true
35 : jhr 4317 | sameSx ((i,_,_)::ix, (j,_,_)::jx) = (i = j) andalso sameSx(ix, jx)
36 :     | sameSx _ = false
37 :     fun sameOp1 (E.Neg, E.Neg) = true
38 :     | sameOp1 (E.Exp, E.Exp) = true
39 :     | sameOp1 (E.Sqrt, E.Sqrt) = true
40 :     | sameOp1 (E.Cosine, E.Cosine) = true
41 :     | sameOp1 (E.ArcCosine, E.ArcCosine) = true
42 :     | sameOp1 (E.Sine, E.Sine) = true
43 :     | sameOp1 (E.ArcSine, E.ArcSine) = true
44 :     | sameOp1 (E.Tangent, E.Tangent) = true
45 :     | sameOp1 (E.ArcTangent, E.ArcTangent) = true
46 :     | sameOp1 (E.PowInt n1, E.PowInt n2) = (n1 = n2)
47 : cchiw 5006 | sameOp1 (E.Abs, E.Abs) = true
48 : cchiw 5285 | sameOp1 (E.Sgn, E.Sgn) = true
49 : jhr 4317 | sameOp1 _ = false
50 :     fun same (e1, e2) = (case (e1, e2)
51 :     of (E.Const c1, E.Const c2) => (c1 = c2)
52 :     | (E.ConstR r1, E.ConstR r2) => Rational.same(r1, r2)
53 :     | (E.Tensor(id1, ix1), E.Tensor(id2, ix2)) =>
54 :     (id1 = id2) andalso sameIndex(ix1, ix2)
55 : cchiw 4555 | (E.Zero(ix1), E.Zero(ix2)) => sameIndex(ix1, ix2)
56 : jhr 4317 | (E.Delta(ix1, jx1), E.Delta(ix2, jx2)) =>
57 : cchiw 3978 (ix1 = ix2) andalso (jx1 = jx2)
58 : jhr 4317 | (E.Epsilon(i1, j1, k1), E.Epsilon(i2, j2, k2)) =>
59 :     (i1 = i2) andalso (j1 = j2) andalso (k1 = k2)
60 :     | (E.Eps2(i1, j1), E.Eps2(i2, j2)) => (i1 = i2) andalso (j1 = j2)
61 :     | (E.Field(id1, ix1), E.Field(id2, ix2)) =>
62 :     (id1 = id2) andalso sameIndex(ix1, ix2)
63 :     | (E.Lift e1, E.Lift e2) => same (e1, e2)
64 :     | (E.Conv(fid1, alpha1, tid1, ix1), E.Conv(fid2, alpha2, tid2, ix2)) =>
65 :     (fid1 = fid2) andalso (tid1 = tid2) andalso
66 :     sameIndex (alpha1, alpha2) andalso sameIndex (ix1, ix2)
67 :     | (E.Partial ix, E.Partial jx) => sameIndex(ix, jx)
68 :     | (E.Apply(e11, e12), E.Apply(e21, e22)) => same(e11, e21) andalso same(e12, e22)
69 :     | (E.Probe(e11, e12), E.Probe(e21, e22)) => same(e11, e21) andalso same(e12, e22)
70 :     | (E.Value i, E.Value j) => (i = j)
71 : cchiw 5314 | (E.Img(id1, ix1, pos1, s1), E.Img(id2, ix2, pos2, s2)) =>
72 :     (id1 = id2) andalso sameList(pos1, pos2) andalso sameIndex(ix1, ix2) andalso (s1 = s2)
73 : jhr 4317 | (E.Krn(id1, ix1, dim1), E.Krn(id2, ix2, dim2)) =>
74 :     (id1 = id2) andalso sameKx(ix1, ix2) andalso (dim1 = dim2)
75 : jhr 5570 | (E.OField(E.CFExp (es1), e1, ix1), E.OField(E.CFExp (es2), e2, ix2)) =>
76 :     same(e1, e2) andalso same(ix1, ix2) andalso ListPair.allEq (op =) (es1, es2)
77 :     | (E.Poly(e1, n1,alpha1), E.Poly(e2, n2, alpha2)) =>
78 :     same(e1, e2) andalso (n1 = n2) andalso sameIndex(alpha1, alpha2)
79 : jhr 4317 | (E.Sum(c1, e1), E.Sum(c2, e2)) => sameSx(c1, c2) andalso same(e1, e2)
80 :     | (E.Op1(op1, e1), E.Op1(op2, e2)) => sameOp1(op1, op2) andalso same(e1, e2)
81 :     | (E.Op2(op1, e11, e12), E.Op2(op2, e21, e22)) =>
82 :     (op1 = op2) andalso same(e11, e21) andalso same(e12, e22)
83 : jhr 5258 | (E.Op3(op1, e11, e12, e13), E.Op3(op2, e21, e22, e23)) =>
84 :     (op1 = op2) andalso same(e11, e21) andalso same(e12, e22) andalso same(e13, e23)
85 : jhr 4317 | (E.Opn(op1, es1), E.Opn(op2, es2)) =>
86 :     (op1 = op2) andalso sameList(es1, es2)
87 :     | _ => false
88 :     (* end case *))
89 :     and sameList ([], []) = true
90 :     | sameList (e1::es1, e2::es2) = same(e1, e2) andalso sameList(es1, es2)
91 :     | sameList _ = false
92 :     in
93 :     same (e1, e2)
94 :     end
95 : jhr 3516
96 :     fun same (E.EIN{params=p1, index=ix1, body=e1}, E.EIN{params=p2, index=ix2, body=e2}) = let
97 : jhr 4317 fun sameParam (E.TEN(i1, shp1), E.TEN(i2, shp2)) =
98 :     (i1 = i2) andalso ListPair.allEq (op =) (shp1, shp2)
99 :     | sameParam (E.FLD i1, E.FLD i2) = (i1 = i2)
100 :     | sameParam (E.KRN, E.KRN) = true
101 :     | sameParam (E.IMG(i1, shp1), E.IMG(i2, shp2)) =
102 :     (i1 = i2) andalso ListPair.allEq (op =) (shp1, shp2)
103 :     | sameParam _ = false
104 :     in
105 :     ListPair.allEq sameParam (p1, p2) andalso
106 :     ListPair.allEq (op =) (ix1, ix2) andalso
107 :     sameExp (e1, e2)
108 :     end
109 : jhr 3516
110 :     fun hash (Ein.EIN{body, ...}) = let
111 :     fun hash' body = let
112 :     fun hashInt i = Word.fromInt i
113 :     fun iter [e] = hash' e
114 :     | iter (e1::es) = hash' e1 + iter es
115 :     fun hashMu (E.C c) = hashInt c + 0w17
116 :     | hashMu (E.V v) = hashInt v
117 :     fun hashAlpha [] = 0w3
118 :     | hashAlpha (e1::es) = hashMu e1 + hashAlpha es
119 :     fun hashDels [] = 0w5
120 :     | hashDels ((i, j)::es) = hashMu i + hashMu j + hashDels es
121 :     in
122 : jhr 4317 case body
123 :     of E.Const i => hashInt i + 0w3
124 : jhr 3516 | E.ConstR _ => 0w5
125 :     | E.Tensor(_, alpha) => 0w23 + hashAlpha alpha
126 : cchiw 4555 | E.Zero(alpha) => 0w107 + hashAlpha alpha
127 : jhr 3516 | E.Delta _ => 0w7
128 :     | E.Epsilon _ => 0w13
129 :     | E.Eps2 _ => 0w17
130 :     | E.Field(_, alpha) => 0w29 + hashAlpha alpha
131 :     | E.Lift e1 => 0w61 + hash' e1
132 :     | E.Conv(_, alpha, _, dx) =>
133 : jhr 4317 0w37 + hashAlpha alpha + hashAlpha dx + hashInt(length dx)
134 : jhr 3516 | E.Partial alpha => 0w19+hashAlpha alpha
135 :     | E.Apply(e1, e2) => 0w97 + hash' e1 + hash' e2
136 :     | E.Probe(e1, e2) => 0w101 + hash' e1 + hash' e2
137 :     | E.Value _ => 0w11
138 : cchiw 5314 | E.Img (_, alpha, es, _) => 0w43 + hashAlpha alpha + iter es
139 : cchiw 3742 | E.Krn (_, dels, dim) => 0w41 + hashDels dels + hashInt dim
140 : jhr 5570 | E.OField(ofld, e2, alpha) => 0w141 +hash' e2 + hash' alpha
141 :     | E.Poly(e1, n1, alpha2) => 0w143 + hash' e1 + hashInt n1 + hashAlpha alpha2
142 : jhr 3516 | E.Sum(c,e1) => 0w53 + hash' e1
143 :     | E.Op1(e1,e2) => (case e1
144 : jhr 5007 of E.Cosine => 0w113 + hash' e2
145 :     | E.ArcCosine => 0w127 + hash' e2
146 :     | E.Sine => 0w131 + hash' e2
147 :     | E.ArcSine => 0w137 + hash' e2
148 :     | E.Tangent => 0w139 + hash' e2
149 :     | E.ArcTangent => 0w149 + hash' e2
150 :     | E.Neg => 0w59 + hash' e2
151 :     | E.Sqrt => 0w67 + hash' e2
152 :     | E.PowInt _ => 0w107 + hash' e2
153 :     | E.Exp => 0w151 + hash' e2
154 :     | E.Abs => 0w157 + hash' e2
155 : cchiw 5285 | E.Sgn => 0w157 + hash' e2
156 : jhr 5007 (* end case *))
157 : jhr 3516 | E.Op2(E.Sub, e1, e2) => 0w79 + hash' e1 + hash' e2
158 :     | E.Op2(E.Div, e1, e2) => 0w83 + hash' e1 + hash' e2
159 : cchiw 5241 | E.Op3(E.Clamp, e1, e2, e3) => 0w163 + hash' e1 + hash' e2 + hash' e3
160 : jhr 3516 | E.Opn(E.Add, es) => 0w71 + iter es
161 :     | E.Opn(E.Prod, es) => 0w103 + iter es
162 : jhr 4317 (* end case *)
163 : jhr 3516 end
164 :     in
165 : jhr 4317 hash' body
166 : jhr 3516 end
167 :    
168 : jhr 5574 fun iterPP es = let
169 :     fun iterP ([], [r]) = r
170 :     | iterP ([], rest) = E.Opn(E.Prod, rest)
171 :     | iterP (E.Const 0::es, rest) = E.Const(0)
172 :     | iterP (E.Const 1::es, rest) = iterP(es, rest)
173 :     | iterP (E.Delta(E.C c1, E.V v1)::E.Delta(E.C c2, E.V v2)::es, rest) =
174 :     (* variable can't be 0 and 1 '*)
175 :     if (c1 = c2)
176 :     then iterP (es, E.Delta(E.C c1, E.V v1)::E.Delta(E.C c2, E.V v2)::rest)
177 :     else E.Const(0)
178 :     | iterP (E.Opn(E.Prod, ys)::es, rest) = iterP(ys@es, rest)
179 :     | iterP (e1::es, rest) = iterP(es, e1::rest)
180 :     in
181 :     iterP (es, [])
182 :     end
183 :    
184 :     fun iterAA es = let
185 :     fun iterA ([], []) = E.Const 0
186 :     | iterA ([], [r]) = r
187 :     | iterA ([], rest) = E.Opn(E.Add, rest)
188 :     | iterA (E.Const 0::es, rest) = iterA(es, rest)
189 :     | iterA (E.Opn(E.Add, ys)::es, rest) = iterA(ys@es, rest)
190 :     | iterA (e1::es, rest) = iterA(es, e1::rest)
191 :     in
192 :     iterA (es, [])
193 :     end
194 :    
195 : jhr 3516 end

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