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 3059 - (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 :     val fromJSON : JSON.value -> benchmark list
40 :     val toJSON : benchmark list -> JSON.value
41 :    
42 :     end = struct
43 :    
44 :     structure J = JSON
45 :    
46 :     (***** JSON Utility code *****)
47 :    
48 :     fun findField (J.OBJECT fields) = let
49 :     fun find lab = (case List.find (fn (l, v) => (l = lab)) fields
50 :     of NONE => NONE
51 :     | SOME(_, v) => SOME v
52 :     (* end case *))
53 :     in
54 :     find
55 :     end
56 :     | findField _ = raise Fail "expected object"
57 :    
58 :     fun lookupField findFn lab = (case findFn lab
59 :     of NONE => raise Fail(concat["no definition for field \"", lab, "\""])
60 :     | SOME v => v
61 :     (* end case *))
62 :    
63 :     fun cvtArray cvtFn (J.ARRAY vl) = List.map cvtFn vl
64 :     | cvtArray cvtFn _ = raise Fail "expected array"
65 :    
66 :     fun cvtInt (J.INT i) = IntInf.toInt i
67 :     | cvtInt _ = raise Fail "expected floating-point number"
68 :    
69 :     fun cvtFloat (J.FLOAT r) = r
70 :     | cvtFloat (J.INT i) = Real.fromLargeInt i
71 :     | cvtFloat _ = raise Fail "expected floating-point number"
72 :    
73 :     fun findInt find = let
74 :     fun get lab = cvtInt (find lab)
75 :     in
76 :     get
77 :     end
78 :    
79 :     fun findFloat find = let
80 :     fun get lab = cvtFloat (find lab)
81 :     in
82 :     get
83 :     end
84 :    
85 :     fun findString find = let
86 :     fun get lab = (case find lab
87 :     of J.STRING s => s
88 :     | _ => raise Fail "expected string"
89 :     (* end case *))
90 :     in
91 :     get
92 :     end
93 :    
94 :     (***** end of JSON utility code *****)
95 :    
96 :     type results = {
97 :     name : string,
98 :     nprocs : int,
99 :     times : real list,
100 :     avg_time : real option,
101 :     std_dev : real option
102 :     }
103 :    
104 :     type benchmark = {
105 :     bmark : string,
106 :     host : string,
107 :     version : string,
108 :     nruns : int,
109 :     max_nprocs : int,
110 :     max_nworkers : int,
111 :     date : string,
112 :     time : string,
113 :     diderotc_flags : string,
114 :     runtime_flags : string,
115 :     results : results list,
116 :     completed_at : string
117 :     }
118 :    
119 : jhr 3059 type data = benchmark list
120 : jhr 3058
121 :     (* convert a JSON results object to the results type *)
122 :     fun jsonToResults (obj : JSON.value) = let
123 :     val find = findField obj
124 :     val lookup = lookupField find
125 :     val times = cvtArray cvtFloat (lookup "times")
126 :     val nTimes = List.length times
127 :     (* if not already computed, compute the average time and standard deviation *)
128 :     val avgTime = if nTimes = 0
129 :     then NONE
130 :     else (case find "avg-time"
131 :     of NONE => SOME((List.foldl Real.+ 0.0 times) / (real nTimes))
132 :     | SOME v => SOME(cvtFloat v)
133 :     (* end case *))
134 :     (* if not already computed, compute the standard deviation *)
135 :     val stdDev = (case avgTime
136 :     of NONE => NONE (* implies that nTimes = 0 *)
137 :     | SOME avg => (case find "std-dev"
138 :     of NONE => let
139 :     fun sqr (x : real) = x*x
140 :     val sumSqrs = List.foldl (fn (x, s) => s + sqr(avg - x)) 0.0 times
141 :     in
142 :     SOME(Math.sqrt(sumSqrs / (real nTimes)))
143 :     end
144 :     | SOME v => SOME(cvtFloat v)
145 :     (* end case *))
146 :     (* end case *))
147 :     in {
148 :     name = findString lookup "name",
149 :     nprocs = findInt lookup "nprocs",
150 :     times = times,
151 :     avg_time = avgTime,
152 :     std_dev = stdDev
153 :     } end
154 :    
155 :     (* convert a JSON object to a benchmark value *)
156 :     fun jsonToBenchmark obj = let
157 :     val lookup = lookupField (findField obj)
158 :     in {
159 :     bmark = findString lookup "bmark",
160 :     host = findString lookup "host",
161 :     version = findString lookup "version",
162 :     nruns = findInt lookup "nruns",
163 :     max_nprocs = findInt lookup "max-nprocs",
164 :     max_nworkers = findInt lookup "max-nworkers",
165 :     date = findString lookup "date",
166 :     time = findString lookup "time",
167 :     diderotc_flags = findString lookup "diderotc-flags",
168 :     runtime_flags = findString lookup "runtime-flags",
169 :     results = cvtArray jsonToResults (lookup "results"),
170 :     completed_at = findString lookup "completed-at"
171 :     } end
172 :    
173 :     fun fromJSON (J.ARRAY objs) = List.map jsonToBenchmark objs
174 :     | fromJSON obj = [jsonToBenchmark obj]
175 :    
176 :     fun resultsToJSON (r : results) = raise Fail "TODO"
177 :    
178 :     fun benchmarkToJSON (b : benchmark) = raise Fail "TODO"
179 :    
180 :     fun toJSON [b] = benchmarkToJSON b
181 :     | toJSON bs = JSON.ARRAY(List.map benchmarkToJSON bs)
182 :    
183 :     fun loadFiles fs = List.foldr
184 :     (fn (f, bmarks) => fromJSON (JSONParser.parseFile f) @ bmarks)
185 :     [] fs
186 :    
187 :     end

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