Cirron v0.2

* Cirron now attempts to measure its own overhead and remove it from the resulting measurement
* Added recording of branch misses and page faults and made it simpler to add more events

Author: s7nfo

cirron/cirron.py

@@ -13,15 +13,23 @@
 
 class Counter(Structure):
     _fields_ = [
-        ("instruction_count", c_uint64),
         ("time_enabled_ns", c_uint64),
+        ("instruction_count", c_uint64),
+        ("branch_misses", c_uint64),
+        ("page_faults", c_uint64),
     ]
 
     def __str__(self):
-        return f"Counter(instruction_count={self.instruction_count}, time_enabled_ns={self.time_enabled_ns})"
+        return self.__repr__()
 
     def __repr__(self):
-        return f"Counter(instruction_count={self.instruction_count}, time_enabled_ns={self.time_enabled_ns})"
+        repr = "Counter("
+
+        for field, _ in Counter._fields_:
+            repr += f"{field}={getattr(self, field)}, "
+        repr = repr[:-2] + ")"
+
+        return repr
 
 
 lib_path = resource_filename(__name__, "cirronlib.so")
@@ -55,4 +63,29 @@ def end(self):
         ret_val = cirron_lib.end(self.fd, byref(self.counter))
         if ret_val == -1:
             raise Exception("Failed to end collector.")
+
+        global overhead
+        if overhead:
+            for field, _ in Counter._fields_:
+                setattr(
+                    self.counter, field, getattr(self.counter, field) - overhead[field]
+                )
         return self.counter
+
+
+# We try to estimate what the overhead of the collector is, taking the minimum
+# of 10 runs.
+overhead = {}
+collector = Collector()
+o = {}
+for _ in range(10):
+    collector.start()
+    collector.end()
+
+    for field, _ in Counter._fields_:
+        if field not in overhead:
+            o[field] = getattr(collector.counter, field)
+        else:
+            o[field] = min(overhead[field], getattr(collector.counter, field))
+overhead = o
+del collector

cirron/cirronlib.c

@@ -6,33 +6,87 @@
 #include <errno.h>
 #include <sys/ioctl.h>
 #include <stdint.h>
+#include <stdlib.h>
 
 struct counter
 {
-    uint64_t instruction_count;
     uint64_t time_enabled_ns;
+    uint64_t instruction_count;
+    uint64_t branch_misses;
+    uint64_t page_faults;
+};
+
+struct read_format
+{
+    uint64_t nr;
+    uint64_t time_enabled;
+    uint64_t time_running;
+    struct
+    {
+        uint64_t value;
+    } values[];
+};
+
+struct perf_event_config
+{
+    uint64_t type;
+    uint64_t config;
+};
+
+struct perf_event_config events[] = {
+    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS},
+    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES},
+    {PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS},
+    // {PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES}, For whatever reason, these two always show 0
+    // {PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS},
 };
 
+const int NUM_EVENTS = sizeof(events) / sizeof(events[0]);
+
 int start()
 {
+    // Construct base perf_event_attr struct
     struct perf_event_attr attr;
     memset(&attr, 0, sizeof(attr));
-    attr.type = PERF_TYPE_HARDWARE;
     attr.size = sizeof(attr);
+    attr.disabled = 1;
     attr.exclude_kernel = 1;
     attr.exclude_hv = 1;
     attr.sample_period = 0;
-    attr.config = PERF_COUNT_HW_INSTRUCTIONS;
-    attr.read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_TOTAL_TIME_RUNNING;
+    attr.read_format = PERF_FORMAT_GROUP | PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_TOTAL_TIME_RUNNING;
+
+    int group = -1;
+    int leader_fd;
+
+    // Enable every event in perf_event_config
+    for (int i = 0; i < NUM_EVENTS; i++)
+    {
+        attr.type = events[i].type;
+        attr.config = events[i].config;
+
+        int fd = syscall(SYS_perf_event_open, &attr, 0, -1, group, 0);
+        if (fd == -1)
+        {
+            fprintf(stderr, "Failed to open event %lu: %s.\n", events[i].config, strerror(errno));
+            return -1;
+        }
+
+        if (i == 0)
+        {
+            group = fd;
+            leader_fd = fd;
+        }
+    }
 
-    int fd = syscall(SYS_perf_event_open, &attr, 0, -1, -1, 0);
-    if (fd == -1)
+    // Enable the event group
+    if (ioctl(leader_fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) == -1)
     {
-        fprintf(stderr, "Failed to perf_event_open: %s.\n", strerror(errno));
+        fprintf(stderr, "Failed to enable perf events: %s.\n", strerror(errno));
+        // Consider cleaning up previously opened file descriptors here
         return -1;
     }
 
-    return fd;
+    return leader_fd;
 }
 
 int end(int fd, struct counter *out)
@@ -43,24 +97,50 @@ int end(int fd, struct counter *out)
         return -1;
     }
 
+    // Disable the event group
     if (ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) == -1)
     {
         fprintf(stderr, "Error disabling perf event (fd: %d): %s\n", fd, strerror(errno));
         return -1;
     }
 
-    uint64_t read_format[5];
-    if (read(fd, read_format, sizeof(read_format)) == -1)
+    // Allocate buffer for reading results
+    int size = sizeof(struct read_format) + (sizeof(uint64_t) * NUM_EVENTS);
+    struct read_format *buffer = (struct read_format *)malloc(size);
+    if (!buffer)
+    {
+        fprintf(stderr, "Failed to allocate memory for read buffer.\n");
+        return -1;
+    }
+
+    // Read results
+    int ret_val = read(fd, buffer, size);
+    if (ret_val == -1)
+    {
+        fprintf(stderr, "Error reading perf event results: %s\n", strerror(errno));
+        free(buffer);
+        return -1;
+    }
+    else if (ret_val != size)
     {
-        fprintf(stderr, "Error reading perf event results (fd: %d): %s\n", fd, strerror(errno));
+        fprintf(stderr, "Error reading perf event results: read %d bytes, expected %d\n", ret_val, size);
+        free(buffer);
         return -1;
     }
-    else
+
+    // Assign time_enabled_ns
+    out->time_enabled_ns = buffer->time_enabled;
+
+    // Directly assign values to struct fields treating them as an array 8)
+    uint64_t *counter_ptr = (uint64_t *)out;
+    counter_ptr++; // Now points to instruction_count, the first counter field
+
+    for (int i = 0; i < NUM_EVENTS; i++)
     {
-        close(fd);
-        out->instruction_count = read_format[0];
-        out->time_enabled_ns = read_format[1];
+        counter_ptr[i] = buffer->values[i].value;
     }
 
+    close(fd);
+    free(buffer);
     return 0;
 }

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name="Cirron",
-    version="0.1",
+    version="0.2",
     packages=["cirron"],
     package_data={
         "cirron": ["cirronlib.c"],