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

SCM Repository

[diderot] Annotation of /benchmarks/analysis/benchmark.sml
ViewVC logotype

Annotation of /benchmarks/analysis/benchmark.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3070 - (view) (download)

1 : jhr 3058 (* benchmark.sml
2 :     *
3 :     * COPYRIGHT (c) 2015 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     * All rights reserved.
5 :     *
6 :     * Code for loading benchmark reports from JSON files.
7 :     *)
8 :    
9 :     structure Benchmark : sig
10 :    
11 :     type results = {
12 :     name : string,
13 :     nprocs : int,
14 :     times : real list,
15 :     avg_time : real option,
16 :     std_dev : real option
17 :     }
18 :    
19 :     type benchmark = {
20 :     bmark : string,
21 :     host : string,
22 :     version : string,
23 :     nruns : int,
24 :     max_nprocs : int,
25 :     max_nworkers : int,
26 :     date : string,
27 :     time : string,
28 :     diderotc_flags : string,
29 :     runtime_flags : string,
30 :     results : results list,
31 :     completed_at : string
32 :     }
33 :    
34 : jhr 3059 type data = benchmark list
35 :    
36 : jhr 3058 (* load a list of benchmark report files, returning a list of benchmarks *)
37 :     val loadFiles : string list -> benchmark list
38 :    
39 : jhr 3070 (* store a list of benchmark records as a JSON file *)
40 :     val storeFile : benchmark list * string -> unit
41 :    
42 :     (* conversion to and from JSON representation *)
43 : jhr 3058 val fromJSON : JSON.value -> benchmark list
44 :     val toJSON : benchmark list -> JSON.value
45 :    
46 :     end = struct
47 :    
48 :     structure J = JSON
49 :    
50 :     (***** JSON Utility code *****)
51 :    
52 :     fun findField (J.OBJECT fields) = let
53 :     fun find lab = (case List.find (fn (l, v) => (l = lab)) fields
54 :     of NONE => NONE
55 :     | SOME(_, v) => SOME v
56 :     (* end case *))
57 :     in
58 :     find
59 :     end
60 :     | findField _ = raise Fail "expected object"
61 :    
62 :     fun lookupField findFn lab = (case findFn lab
63 :     of NONE => raise Fail(concat["no definition for field \"", lab, "\""])
64 :     | SOME v => v
65 :     (* end case *))
66 :    
67 :     fun cvtArray cvtFn (J.ARRAY vl) = List.map cvtFn vl
68 :     | cvtArray cvtFn _ = raise Fail "expected array"
69 :    
70 :     fun cvtInt (J.INT i) = IntInf.toInt i
71 :     | cvtInt _ = raise Fail "expected floating-point number"
72 :    
73 :     fun cvtFloat (J.FLOAT r) = r
74 :     | cvtFloat (J.INT i) = Real.fromLargeInt i
75 :     | cvtFloat _ = raise Fail "expected floating-point number"
76 :    
77 :     fun findInt find = let
78 :     fun get lab = cvtInt (find lab)
79 :     in
80 :     get
81 :     end
82 :    
83 :     fun findFloat find = let
84 :     fun get lab = cvtFloat (find lab)
85 :     in
86 :     get
87 :     end
88 :    
89 :     fun findString find = let
90 :     fun get lab = (case find lab
91 :     of J.STRING s => s
92 :     | _ => raise Fail "expected string"
93 :     (* end case *))
94 :     in
95 :     get
96 :     end
97 :    
98 :     (***** end of JSON utility code *****)
99 :    
100 :     type results = {
101 :     name : string,
102 :     nprocs : int,
103 :     times : real list,
104 :     avg_time : real option,
105 :     std_dev : real option
106 :     }
107 :    
108 :     type benchmark = {
109 :     bmark : string,
110 :     host : string,
111 :     version : string,
112 :     nruns : int,
113 :     max_nprocs : int,
114 :     max_nworkers : int,
115 :     date : string,
116 :     time : string,
117 :     diderotc_flags : string,
118 :     runtime_flags : string,
119 :     results : results list,
120 :     completed_at : string
121 :     }
122 :    
123 : jhr 3059 type data = benchmark list
124 : jhr 3058
125 :     (* convert a JSON results object to the results type *)
126 :     fun jsonToResults (obj : JSON.value) = let
127 :     val find = findField obj
128 :     val lookup = lookupField find
129 :     val times = cvtArray cvtFloat (lookup "times")
130 :     val nTimes = List.length times
131 :     (* if not already computed, compute the average time and standard deviation *)
132 :     val avgTime = if nTimes = 0
133 :     then NONE
134 :     else (case find "avg-time"
135 :     of NONE => SOME((List.foldl Real.+ 0.0 times) / (real nTimes))
136 :     | SOME v => SOME(cvtFloat v)
137 :     (* end case *))
138 :     (* if not already computed, compute the standard deviation *)
139 :     val stdDev = (case avgTime
140 :     of NONE => NONE (* implies that nTimes = 0 *)
141 :     | SOME avg => (case find "std-dev"
142 :     of NONE => let
143 :     fun sqr (x : real) = x*x
144 :     val sumSqrs = List.foldl (fn (x, s) => s + sqr(avg - x)) 0.0 times
145 :     in
146 :     SOME(Math.sqrt(sumSqrs / (real nTimes)))
147 :     end
148 :     | SOME v => SOME(cvtFloat v)
149 :     (* end case *))
150 :     (* end case *))
151 :     in {
152 :     name = findString lookup "name",
153 :     nprocs = findInt lookup "nprocs",
154 :     times = times,
155 :     avg_time = avgTime,
156 :     std_dev = stdDev
157 :     } end
158 :    
159 :     (* convert a JSON object to a benchmark value *)
160 :     fun jsonToBenchmark obj = let
161 :     val lookup = lookupField (findField obj)
162 :     in {
163 :     bmark = findString lookup "bmark",
164 :     host = findString lookup "host",
165 :     version = findString lookup "version",
166 :     nruns = findInt lookup "nruns",
167 :     max_nprocs = findInt lookup "max-nprocs",
168 :     max_nworkers = findInt lookup "max-nworkers",
169 :     date = findString lookup "date",
170 :     time = findString lookup "time",
171 :     diderotc_flags = findString lookup "diderotc-flags",
172 :     runtime_flags = findString lookup "runtime-flags",
173 :     results = cvtArray jsonToResults (lookup "results"),
174 :     completed_at = findString lookup "completed-at"
175 :     } end
176 :    
177 :     fun fromJSON (J.ARRAY objs) = List.map jsonToBenchmark objs
178 :     | fromJSON obj = [jsonToBenchmark obj]
179 :    
180 : jhr 3070 fun resultsToJSON (r : results) = let
181 :     (* build reverse-order list of fields *)
182 :     val fields = []
183 :     val fields = ("name", J.STRING(#name r)) :: fields
184 :     val fields = ("nprocs", J.INT(IntInf.fromInt(#nprocs r))) :: fields
185 :     val fields = ("times", J.ARRAY(List.map J.FLOAT (#times r))) :: fields
186 :     val fields = (case #avg_time r
187 :     of SOME t => ("avg-time", J.FLOAT t) :: fields
188 :     | NONE => fields
189 :     (* end case *))
190 :     val fields = (case #std_dev r
191 :     of SOME t => ("std-dev", J.FLOAT t) :: fields
192 :     | NONE => fields
193 :     (* end case *))
194 :     in
195 :     J.OBJECT(List.rev fields)
196 :     end
197 : jhr 3058
198 : jhr 3070 fun benchmarkToJSON (b : benchmark) = let
199 :     (* build reverse-order list of fields *)
200 :     val fields = []
201 :     val fields = ("bmark", J.STRING(#bmark b)) :: fields
202 :     val fields = ("host", J.STRING(#host b)) :: fields
203 :     val fields = ("version", J.STRING(#version b)) :: fields
204 :     val fields = ("nruns", J.INT(IntInf.fromInt(#nruns b))) :: fields
205 :     val fields = ("max-nprocs", J.INT(IntInf.fromInt(#max_nprocs b))) :: fields
206 :     val fields = ("max-nworkers", J.INT(IntInf.fromInt(#max_nworkers b))) :: fields
207 :     val fields = ("date", J.STRING(#date b)) :: fields
208 :     val fields = ("time", J.STRING(#time b)) :: fields
209 :     val fields = ("diderotc-flags", J.STRING(#diderotc_flags b)) :: fields
210 :     val fields = ("runtime-flags", J.STRING(#runtime_flags b)) :: fields
211 :     val fields = ("results", J.ARRAY(List.map resultsToJSON (#results b))) :: fields
212 :     val fields = ("completed-at", J.STRING(#completed_at b)) :: fields
213 :     in
214 :     J.OBJECT(List.rev fields)
215 :     end
216 : jhr 3058
217 :     fun toJSON [b] = benchmarkToJSON b
218 :     | toJSON bs = JSON.ARRAY(List.map benchmarkToJSON bs)
219 :    
220 :     fun loadFiles fs = List.foldr
221 :     (fn (f, bmarks) => fromJSON (JSONParser.parseFile f) @ bmarks)
222 :     [] fs
223 :    
224 : jhr 3070 (* store a list of benchmark records as a JSON file *)
225 :     fun storeFile (bmarks, file) = let
226 :     val outS = TextIO.openOut file
227 :     in
228 :     JSONPrinter.print' {strm=outS, pretty=true} (toJSON bmarks)
229 :     handle ex => (TextIO.closeOut outS; raise ex);
230 :     TextIO.closeOut outS
231 :     end
232 :    
233 : jhr 3058 end

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