modelzoo_tools/exec_timer.py at master · Shan2L/modelzoo_tools · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
from contextlib import contextmanager
import time
from collections import defaultdict
import math
import csv


class ExecTimer:
    def __init__(self, log_file: str = "result.csv", iters: int = 10):
        self.record = defaultdict(list)
        self.iters = iters
        self.log_file = log_file

    @contextmanager
    def record_event(self, name: str):
        timestamp1 = time.perf_counter()
        if len(self.record[name]) != 0:
            last_dict = self.record[name][-1]
            if last_dict["end"] == 0.0:
                raise ValueError("The last time counter has not been closed yet.")

        counter_dict = defaultdict(float)
        counter_dict["start"] = timestamp1
        self.record[name].append(counter_dict)

        yield

        timestamp2 = time.perf_counter()
        if len(self.record[name]) == 0:
            raise RuntimeError(f"The counter {name} has not been started yet.")

        last_dict = self.record[name][-1]
        if last_dict["end"] != 0.0:
            raise RuntimeError(f"The counter {name} has not been started yet.")

        last_dict["end"] = timestamp2
        eclapsed_time = last_dict["end"] - last_dict["start"]

        last_dict["eclapsed"] = eclapsed_time
        # print(f"[INFO] The event {name} ends, eclapsed_time is {eclapsed_time*100}(ms)")

    def analyze_data(self):
        title_strs = [
            "Event Name",
            "Iters",
            "Total Cost(ms)",
            "Max Cost(ms)",
            "Min Cost(ms)",
            "Avg Cost(ms)",
        ]
        with open(self.log_file, "w") as table:
            print(
                f"[INFO] {title_strs[0]:<20}  {title_strs[1]:<10}  {title_strs[2]:<20}"
                f"{title_strs[3]:<20}  {title_strs[4]:<20} {title_strs[5]:<20}"
            )
            writer = csv.writer(table, delimiter=",")
            writer.writerow(title_strs)
            for event_name, event_records in self.record.items():
                if len(event_records) != self.iters:
                    raise ValueError("The number of events are not same")

                event_time_sum = 0.0
                maximum = -math.inf
                minimum = math.inf
                for item in event_records:
                    eclapsed_time = item["eclapsed"]
                    event_time_sum += eclapsed_time
                    if eclapsed_time > maximum:
                        maximum = eclapsed_time
                    if eclapsed_time < minimum:
                        minimum = eclapsed_time
                print(
                    f"[INFO] {event_name:<20}  {self.iters:<10}  {event_time_sum * 100:<20.2f}  "
                    f"{maximum * 100:<20.2f}  {minimum * 100:<20.2f}  {event_time_sum / self.iters * 100:<20.2f}"
                )
                writer.writerow(
                    [
                        event_name,
                        f"{self.iters:10}",
                        f"{event_time_sum * 100:.2f}",
                        f"{maximum * 100:.2f}",
                        f"{minimum * 100:.2f}",
                        f"{event_time_sum / self.iters * 100:.2f}",
                    ]
                )

            total_sum_time = 0.0
            max_sum_time = -math.inf
            min_sum_time = math.inf

            for i in range(self.iters):
                sum_eclapsed = 0.0
                for event_record, event_record in self.record.items():
                    sum_eclapsed += event_record[i]["eclapsed"]
                if sum_eclapsed < min_sum_time:
                    min_sum_time = sum_eclapsed
                if sum_eclapsed > max_sum_time:
                    max_sum_time = sum_eclapsed
                total_sum_time += sum_eclapsed
            event_str = "total_time"
            print(
                f"[INFO] {event_str:<20}  {self.iters:<10}  {total_sum_time * 100:<20.2f}  "
                f"{max_sum_time * 100:<20.2f}  {min_sum_time * 100:<20.2f}  {total_sum_time / self.iters * 100:<20.2f}"
            )
            writer.writerow(
                [
                    event_str,
                    f"{self.iters:10}",
                    f"{total_sum_time * 100:.2f}",
                    f"{max_sum_time * 100:.2f}",
                    f"{min_sum_time * 100:.2f}",
                    f"{total_sum_time / self.iters * 100:.2f}",
                ]
            )