save

Author: Bart van der Vecht

examples/stack/partial_bqc/example_bqc_5_4.py

@@ -2,10 +2,13 @@
 
 import math
 import os
+import random
 import time
-from typing import Any, Dict, Generator
+from dataclasses import dataclass
+from typing import Any, Dict, Generator, List, Tuple
 
 from netqasm.lang.parsing.text import parse_text_presubroutine
+from profiling import profile
 
 from pydynaa import EventExpression
 from squidasm.run.stack.config import (
@@ -24,7 +27,8 @@
     server_subrt_text = f.read()
 SERVER_SUBRT = parse_text_presubroutine(server_subrt_text)
 
-USE_CUSTOM_SUBROUTINES = False
+PRECOMPILE = False
+RANDOMIZE_ANGLE = False
 
 
 class ClientProgram(Program):
@@ -60,13 +64,23 @@ def run(
         p1 = epr.measure(store_array=False)
 
         yield from conn.flush()
+
+        start = time.time() * 1e6
+        process_start = time.process_time() * 1e6
+
         p1 = int(p1)
 
         delta1 = self._alpha - self._theta1 + (p1 + self._r1) * math.pi
 
+        end = time.time() * 1e6
+        process_end = time.process_time() * 1e6
+
+        duration = end - start
+        process_duration = process_end - process_start
+
         csocket.send_float(delta1)
 
-        return {"p1": p1}
+        return {"p1": p1, "duration": duration, "process_duration": process_duration}
 
 
 class ServerProgram(Program):
@@ -93,33 +107,62 @@ def run(
         yield from conn.flush()
 
         delta1 = yield from csocket.recv_float()
+        if RANDOMIZE_ANGLE:
+            delta1 = random.choice([0, PI_OVER_2, PI, -PI_OVER_2])
         start = time.time() * 1e6
+        process_start = time.process_time() * 1e6
 
-        if USE_CUSTOM_SUBROUTINES:
+        if PRECOMPILE:
             SERVER_SUBRT.app_id = conn.app_id
             # print(SERVER_SUBRT.commands[1].operands)
             SERVER_SUBRT.commands[1].operands[1] = 3
             SERVER_SUBRT.commands[1].operands[2] = 1
-            # for i in range(int(1e4)):
-            #     pass
             end = time.time() * 1e6
+            process_end = time.process_time() * 1e6
             yield from conn.commit_subroutine(SERVER_SUBRT)
-            m2 = 0
+            m2 = conn.shared_memory.get_register("M0")
         else:
             epr.rot_Z(angle=delta1)
             epr.H()
             m2 = epr.measure(store_array=False)
 
-            # for i in range(int(1e4)):
-            #     pass
-            end = time.time() * 1e6
+            # end = time.time() * 1e6
+            # process_end = time.process_time() * 1e6
+            # yield from conn.flush()
 
-            yield from conn.flush()
+            subroutine = conn._builder._pop_pending_subroutine()
+            end = time.time() * 1e6
+            process_end = time.process_time() * 1e6
+            yield from conn.commit_subroutine(subroutine)
             m2 = int(m2)
 
         duration = end - start
+        process_duration = process_end - process_start
+
+        return {"m2": m2, "duration": duration, "process_duration": process_duration}
+
+
+@dataclass
+class Statistics:
+    name: str
+    mean: float
+    std_error: float
+    min_value: float
+    max_value: float
 
-        return {"m2": m2, "duration": duration}
+    def to_string(self):
+        return f"[{self.name}] {self.mean}, {self.std_error} (max: {self.max_value}, min: {self.min_value})"
+
+
+def compute_statistics(name: str, items: List[Any]) -> Statistics:
+    length = len(items)
+    mean = round(sum(items) / length, 3)
+    variance = sum((d - mean) * (d - mean) for d in items) / length
+    std_deviation = math.sqrt(variance)
+    std_error = round(std_deviation / math.sqrt(length), 3)
+    min_value = min(items)
+    max_value = max(items)
+    return Statistics(name, mean, std_error, min_value, max_value)
 
 
 def get_distribution(
@@ -132,30 +175,40 @@ def get_distribution(
     client_program = ClientProgram(alpha=alpha, theta1=theta1, r1=r1)
     server_program = ServerProgram()
 
-    _, server_results = run(
+    client_results, server_results = run(
         cfg, {"client": client_program, "server": server_program}, num_times
     )
 
     durations = [result["duration"] for result in server_results]
+    process_durations = [result["process_duration"] for result in server_results]
     # print(durations)
-
-    mean = round(sum(durations) / len(durations), 3)
-    variance = sum((d - mean) * (d - mean) for d in durations) / len(durations)
-    std_deviation = math.sqrt(variance)
-    std_error = round(std_deviation / math.sqrt(len(durations)), 3)
-
-    max_dur = max(durations)
-    min_dur = min(durations)
-
-    print(f"{mean}, {std_error} (max: {max_dur}, min: {min_dur})")
+    m2s = [result["m2"] for result in server_results]
+
+    client_durations = [result["duration"] for result in client_results]
+    client_process_durations = [result["process_duration"] for result in client_results]
+
+    print("\nserver:")
+    print(compute_statistics("durations", durations).to_string())
+    print(compute_statistics("process_durations", process_durations).to_string())
+    # print(compute_statistics("m2", m2s).to_string())
+
+    print("\nclient:")
+    print(compute_statistics("client_durations", client_durations).to_string())
+    print(
+        compute_statistics(
+            "client_process_durations", client_process_durations
+        ).to_string()
+    )
+    print(client_durations)
 
 
 PI = math.pi
 PI_OVER_2 = math.pi / 2
 
 
+# @profile(sort_by="cumulative", lines_to_print=1000, strip_dirs=True)
 def main():
-    num_times = 100
+    num_times = 1000
 
     client_stack = StackConfig(
         name="client",
@@ -179,7 +232,12 @@ def main():
 
 
 if __name__ == "__main__":
-    USE_CUSTOM_SUBROUTINES = False
+    RANDOMIZE_ANGLE = True
+
+    print("NO PRECOMPILE:")
+    PRECOMPILE = False
     main()
-    USE_CUSTOM_SUBROUTINES = True
+
+    print("\nPRECOMPILE:")
+    PRECOMPILE = True
     main()