Newer
Older
#!/usr/bin/env python3
from __future__ import annotations
import statistics
import sys
from csv import DictReader, DictWriter
from dataclasses import asdict, dataclass, fields
from pathlib import Path
MAPPING: dict[str, str] = {
"ca-c-clang": "clang",
"ca-c-gcc": "gcc",
"ca-cpp-clang": "clang++",
"ca-cpp-gcc": "g++",
"ca-fortran-gcc": "gfortran",
"ca-fortran-llvm-flang": "flang-new",
"ca-julia": "julia",
"rodinia-srad-c-clang": "clang",
"rodinia-srad-c-gcc": "gcc",
"rodinia-srad-cpp-clang": "clang++",
"rodinia-srad-cpp-gcc": "g++",
"rodinia-srad-fortran-gcc": "gfortran",
"rodinia-srad-fortran-llvm-flang": "flang-new",
"rodinia-srad-julia": "julia",
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
}
@dataclass
class Input(object):
thread: str
region_idf: str
file: str
line: str
function: str
visits: str
device_name: str
energy: str
time: str
@dataclass
class Result(object):
name: str
energy_min: float
energy_avg: float
energy_max: float
energy_std: float
energy_var: float
time_min: float
time_avg: float
time_max: float
time_std: float
time_var: float
memory_min: float
memory_avg: float
memory_max: float
memory_std: float
memory_var: float
def main(args: list[str]) -> int:
path: Path = Path(args[0])
programs: list[Path] = [x for x in path.glob("*") if x.is_dir()]
with (path / "combined.csv").open("w") as f:
combined: DictWriter = DictWriter(
f, [x.name for x in fields(Result)], delimiter=" "
)
combined.writeheader()
for program in sorted(programs):
energy: list[float] = []
time: list[float] = []
memory: list[float] = []
name: str = MAPPING[program.name]
with (path / f"{name}.csv").open("w") as r:
runs: DictWriter = DictWriter(
r, ["run", "energy", "time", "memory"], delimiter=" "
)
runs.writeheader()
for run in sorted(program.glob("*")):
m: float = int((run / "memory_usage.txt").read_text()) / 1024
memory.append(m)
ema: Path = next(run.glob("output.EMA.*"))
with ema.open() as f:
reader: DictReader = DictReader(f)
for line in reader:
input: Input = Input(**line)
if input.device_name != args[1]:
continue
e: float = int(input.energy) / 1000 / 1000 / 1000
t: float = int(input.time) / 1000 / 1000
runs.writerow(
{"run": run.name, "energy": e, "time": t, "memory": m}
)
energy.append(e)
time.append(t)
result: Result = Result(
name=MAPPING[program.name],
energy_min=min(energy),
energy_avg=statistics.mean(energy),
energy_max=max(energy),
energy_std=statistics.stdev(energy),
energy_var=statistics.variance(energy),
time_min=min(time),
time_avg=statistics.mean(time),
time_max=max(time),
time_std=statistics.stdev(time),
time_var=statistics.variance(time),
memory_min=min(memory),
memory_avg=statistics.mean(memory),
memory_max=max(memory),
memory_std=statistics.stdev(memory),
memory_var=statistics.variance(memory),
)
combined.writerow(asdict(result))
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))