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

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