workload → pta-workload

1 files changed, 92 insertions, 0 deletions

diff --git a/bin/pta-workload.py b/bin/pta-workload.py
new file mode 100755
index 0000000..19a7378
--- /dev/null
+++ b/bin/pta-workload.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+
+import sys
+from dfatool.automata import PTA
+from dfatool.utils import human_readable
+from dfatool.lex import TimedSequence, TimedWord, Workload
+
+args = sys.argv[1:]
+
+loops = dict()
+ptafiles = list()
+loop_names = set()
+
+
+def simulate_word(timedword):
+    prev_state = "UNINITIALIZED"
+    prev_param = None
+    ret = dict()
+    for trace_part in timedword:
+        print("Trace Part {}".format(trace_part))
+        if type(trace_part) is TimedWord:
+            result = pta.simulate(
+                trace_part, orig_state=prev_state, orig_param=prev_param
+            )
+        elif type(trace_part) is Workload:
+            result = pta.simulate(
+                trace_part.word, orig_state=prev_state, orig_param=prev_param
+            )
+            if prev_state != result.end_state:
+                print(
+                    "Warning: loop starts in state {}, but terminates in {}".format(
+                        prev_state, result.end_state.name
+                    )
+                )
+            if prev_param != result.parameters:
+                print(
+                    "Warning: loop starts with parameters {}, but terminates with {}".format(
+                        prev_param, result.parameters
+                    )
+                )
+            ret[trace_part.name] = result
+            loop_names.add(trace_part.name)
+
+        print("    Duration: " + human_readable(result.duration, "s"))
+        if result.duration_mae:
+            print(
+                u"    ± {}  /  {:.0f}%".format(
+                    human_readable(result.duration_mae, "s"), result.duration_mape
+                )
+            )
+        print("    Energy: " + human_readable(result.energy, "J"))
+        if result.energy_mae:
+            print(
+                u"    ± {}  /  {:.0f}%".format(
+                    human_readable(result.energy_mae, "J"), result.energy_mape
+                )
+            )
+        print("    Mean Power: " + human_readable(result.mean_power, "W"))
+        print("")
+
+        prev_state = result.end_state
+        prev_param = result.parameters
+
+    return ret
+
+
+for i in range(len(args) // 2):
+    ptafile, raw_word = args[i * 2], args[i * 2 + 1]
+    ptafiles.append(ptafile)
+    pta = PTA.from_file(ptafile)
+    timedword = TimedSequence(raw_word)
+    print("Input: {}\n".format(timedword))
+    loops[ptafile] = simulate_word(timedword)
+
+for loop_name in sorted(loop_names):
+    result_set = list()
+    total_power = 0
+    for ptafile in sorted(ptafiles):
+        if loop_name in loops[ptafile]:
+            result_set.append(loops[ptafile][loop_name])
+            total_power += loops[ptafile][loop_name].mean_power
+    print(
+        "{}: total mean power is {}".format(loop_name, human_readable(total_power, "W"))
+    )
+    for i, result in enumerate(result_set):
+        print(
+            "    {:.0f}% {} (period: {})".format(
+                result.mean_power * 100 / total_power,
+                ptafiles[i],
+                human_readable(result.duration, "s"),
+            )
+        )