2026-03-21 - Different Ways to Read CTF

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <string.h>
#include <babeltrace2/babeltrace.h>

typedef struct fatcharp {
	char *s;
	size_t len;
} fatcharp;

/* fnv-1a for non null-terminated fatcharps */
static inline size_t fatcharp_hash_fnv(fatcharp p)
{
	size_t prime, offset_basis;
	if (sizeof(prime) == 4) {
		prime = UINT32_C(16777619);
		offset_basis = UINT32_C(2166136261);
	} else { // assume 64-bit
		prime = UINT64_C(1099511628211);
		offset_basis = UINT64_C(14695981039346656037);
	}
	size_t hash = offset_basis;
	for (size_t i = 0; i < p.len; i++) {
		hash ^= p.s[i];
		hash *= prime;
	}
	return hash;
}

static inline int fatcharpcmp(fatcharp p1, fatcharp p2) {
	if (p1.len < p2.len) {
		return -1;
	} else if (p1.len > p2.len) {
		return 1;
	} else {
		return strncmp(p1.s, p2.s, p1.len);
	}
}

static void fatcharp_free(fatcharp f)
{
	free(f.s);
}

#define MAP_NAME fatcharptou64
#define MAP_KEY_TYPE fatcharp
#define MAP_KEY_FREE fatcharp_free
#define MAP_KEY_CMP fatcharpcmp
#define MAP_VAL_TYPE uint64_t
#define MAP_HASH fatcharp_hash_fnv
#include "crust/map.h"

struct cpudata {
	int64_t last_tstamp;
	fatcharptou64 tasktotime;
};

static void cpudata_free(struct cpudata d)
{
	fatcharptou64_free(&d.tasktotime);
}

#define MAP_NAME u64tocpudata
#define MAP_KEY_TYPE uint64_t
#define MAP_KEY_CMP uint64cmp
#define MAP_VAL_TYPE struct cpudata
#define MAP_VAL_FREE cpudata_free
#define MAP_HASH hash_uint64
#include "crust/map.h"

struct task {
	fatcharp name;
	uint64_t time;
};

static int tasktimecmp(const void *a0, const void *a1)
{
	const struct task *t0 = a0;
	const struct task *t1 = a1;
	if (t0->time > t1->time) {
		return -1;
	} else if (t0->time < t1->time) {
		return 1;
	} else {
		return 0;
	}
}

struct process_out {
	bt_message_iterator *message_iterator;
	u64tocpudata cputodata;
};

static bt_component_class_initialize_method_status process_out_initialize(
        bt_self_component_sink *self_component_sink,
        bt_self_component_sink_configuration *configuration,
        const bt_value *params, void *initialize_method_data)
{
	struct process_out *process_out = malloc(sizeof(*process_out));
	u64tocpudata_init_cap(&process_out->cputodata, 16);

	bt_self_component_set_data(
		bt_self_component_sink_as_self_component(self_component_sink),
		process_out);
	bt_self_component_sink_add_input_port(self_component_sink,
					      "in", NULL, NULL);
	return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
}

static int u64cmp(const void *a0, const void *a1)
{
	const uint64_t *v0 = a0;
	const uint64_t *v1 = a1;
	if (*v0 < *v1) {
		return -1;
	} else if (*v0 > *v1) {
		return 1;
	} else {
		return 0;
	}
}

static void process_out_finalize(bt_self_component_sink *self_component_sink)
{
	struct process_out *p = bt_self_component_get_data(
		bt_self_component_sink_as_self_component(self_component_sink));

	uint64_t *cpus = malloc(sizeof(*cpus) * p->cputodata.len);
	struct cpudata tmp;
	struct u64tocpudata_it it = { 0 };
	for (size_t i = 0; u64tocpudata_foreach(&p->cputodata, &cpus[i],
						&tmp, &it) == 0; i++) {};
	qsort(cpus, p->cputodata.len, sizeof(*cpus), u64cmp);

	for (size_t i = 0; i < p->cputodata.len; i++) {
		printf("CPU %"PRIu64"\n", cpus[i]);
		struct cpudata *data = u64tocpudata_find(&p->cputodata, cpus[i]);

		struct task *tasks = malloc(sizeof(*tasks) * data->tasktotime.len);
		struct fatcharptou64_it it = { 0 };
		for (size_t i = 0; fatcharptou64_foreach(&data->tasktotime, &tasks[i].name,
							 &tasks[i].time, &it) == 0; i++) {};

		qsort(tasks, data->tasktotime.len, sizeof(*tasks), tasktimecmp);
		for (size_t i = 0; i < data->tasktotime.len && i < 5; i++) {
			printf("%20.*s: %f s\n", tasks[i].name.len, tasks[i].name.s,
			       (double)tasks[i].time / 1000000000);
		}
		free(tasks);
	}
	free(cpus);

	u64tocpudata_free(&p->cputodata);
	free(p);
}

static bt_component_class_sink_graph_is_configured_method_status process_out_graph_is_configured(
	bt_self_component_sink *self_component_sink)
{
	struct process_out *process_out = bt_self_component_get_data(
		bt_self_component_sink_as_self_component(self_component_sink));

	bt_self_component_port_input *in_port =
		bt_self_component_sink_borrow_input_port_by_index(
			self_component_sink, 0);
	bt_message_iterator_create_from_sink_component(self_component_sink,
						       in_port, &process_out->message_iterator);

	return BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
}

static bt_component_class_get_supported_mip_versions_method_status process_get_supported_mip_versions_method(
	bt_self_component_class_sink *source_component_class,
	const bt_value *params, void *initialize_method_data,
	bt_logging_level logging_level,
	bt_integer_range_set_unsigned *supported_versions)
{
	bt_integer_range_set_unsigned_add_range(supported_versions, 0, 1);
	return BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
}

static void process(struct process_out *p, const bt_message *msg)
{
	if (bt_message_get_type(msg) != BT_MESSAGE_TYPE_EVENT) {
		return;
	}

	const bt_event *ev = bt_message_event_borrow_event_const(msg);
	const bt_event_class *evc = bt_event_borrow_class_const(ev);
	const char *name = bt_event_class_get_name(evc);
	if (strcmp(name, "sched:sched_switch") != 0) {
		return;
	}
	int64_t tstamp;
	bt_clock_snapshot_get_ns_from_origin(
		bt_message_event_borrow_default_clock_snapshot_const(msg), &tstamp);
	uint64_t cpu_id = bt_field_integer_unsigned_get_value(
		bt_field_structure_borrow_member_field_by_name_const(
			bt_packet_borrow_context_field_const(bt_event_borrow_packet_const(ev)), "cpu_id"));
	struct cpudata *data = u64tocpudata_find(&p->cputodata, cpu_id);
	if (! data) {
		struct cpudata d;
		d.last_tstamp = tstamp;
		fatcharptou64_init_cap(&d.tasktotime, 16);
		u64tocpudata_insert(&p->cputodata, cpu_id, d);
		data = u64tocpudata_find(&p->cputodata, cpu_id);
	}

	const bt_field *prev_comm_fld = bt_field_structure_borrow_member_field_by_name_const(
		bt_event_borrow_payload_field_const(ev), "prev_comm");
	fatcharp prev_comm = {
		.s = (char *)bt_field_string_get_value(prev_comm_fld),
		.len = bt_field_string_get_length(prev_comm_fld)
	};

	uint64_t diff = (uint64_t)(tstamp - data->last_tstamp);

	uint64_t *t = fatcharptou64_find(&data->tasktotime, prev_comm);
	if (t) {
		*t += diff;
	} else {
		prev_comm.s = strdup(prev_comm.s);
		fatcharptou64_insert(&data->tasktotime, prev_comm, diff);
	}

	data->last_tstamp = tstamp;
}

static bt_component_class_sink_consume_method_status process_out_consume(
        bt_self_component_sink *self_component_sink)
{
	bt_component_class_sink_consume_method_status status =
		BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;

	struct process_out *process_out = bt_self_component_get_data(
		bt_self_component_sink_as_self_component(self_component_sink));

	bt_message_array_const messages;
	uint64_t message_count;
	bt_message_iterator_next_status next_status =
		bt_message_iterator_next(process_out->message_iterator, &messages,
					 &message_count);
	switch (next_status) {
	case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
		bt_message_iterator_put_ref(process_out->message_iterator);
		status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_END;
		goto end;
	case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
		status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_AGAIN;
		goto end;
	case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
		status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_MEMORY_ERROR;
		goto end;
	case BT_MESSAGE_ITERATOR_NEXT_STATUS_ERROR:
		status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
		goto end;
	default:
		break;
	}

	for (uint64_t i = 0; i < message_count; i++) {
		const bt_message *message = messages[i];
		process(process_out, message);
		bt_message_put_ref(message);
	}
end:
	return status;
}

BT_PLUGIN_MODULE();
BT_PLUGIN(process);
BT_PLUGIN_SINK_COMPONENT_CLASS(output, process_out_consume);
BT_PLUGIN_SINK_COMPONENT_CLASS_INITIALIZE_METHOD(output, process_out_initialize);
BT_PLUGIN_SINK_COMPONENT_CLASS_FINALIZE_METHOD(output, process_out_finalize);
BT_PLUGIN_SINK_COMPONENT_CLASS_GRAPH_IS_CONFIGURED_METHOD(output, process_out_graph_is_configured);
BT_PLUGIN_SINK_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD(output, process_get_supported_mip_versions_method);

import bt2
import sys
import collections

class CpuData:
    def __init__(self, tstamp):
        self.last_tstamp = tstamp
        self.exec_times = collections.Counter()

cputodata = {}

for msg in bt2.TraceCollectionMessageIterator(sys.argv[1]):
    if type(msg) is not bt2._EventMessageConst:
        continue
    event = msg.event
    if event.name != 'sched:sched_switch':
        continue
    tstamp = msg.default_clock_snapshot.ns_from_origin
    cpu = int(event['cpu_id'])
    data = cputodata.get(cpu)
    if data is None:
        data = CpuData(tstamp)
        cputodata[cpu] = data

    prev_comm = str(event['prev_comm'])
    diff = tstamp - data.last_tstamp
    data.exec_times[prev_comm] += diff
    data.last_tstamp = tstamp

for cpu, data in sorted(cputodata.items()):
    print(f"CPU {cpu}")
    for comm, ns in data.exec_times.most_common(5):
        print('\t{:20}{} s'.format(comm, ns / 1e9))

import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.event.IEventDefinition;
import org.eclipse.tracecompass.ctf.core.event.types.StringDefinition;
import org.eclipse.tracecompass.ctf.core.event.types.SimpleDatatypeDefinition;

class CpuData {
	long last_tstamp;
	Map<String, Long> tasktotime;

	CpuData(long tstamp) {
		last_tstamp = tstamp;
		tasktotime = new HashMap<>();
	}
}

void process(IEventDefinition defs, Map<Long, CpuData> cpu_to_data)
{
	var name = defs.getDeclaration().getName();
	if (! name.equals("sched:sched_switch")) {
		return;
	}
	var tstamp = defs.getTimestamp();
	var flds = defs.getFields();
	var cpu_id = ((SimpleDatatypeDefinition)defs.getPacketContext()
		.getDefinition("cpu_id")).getIntegerValue();
	var data = cpu_to_data.computeIfAbsent(cpu_id, k -> new CpuData(tstamp));

	var prev_comm = ((StringDefinition)flds.getDefinition("prev_comm"))
		.getValue();

	var diff = tstamp - data.last_tstamp;

	data.tasktotime.compute(prev_comm, (k, v) -> (v == null) ? diff : v + diff);
	data.last_tstamp = tstamp;
}

public void main(String[] args) throws CTFException {
	var path = args[0];
	CTFTrace trace = new CTFTrace(path);
	CTFTraceReader reader = new CTFTraceReader(trace);

	var cpu_to_data = new HashMap<Long, CpuData>();
	while (reader.hasMoreEvents()) {
		var defs = reader.getCurrentEventDef();
		process(reader.getCurrentEventDef(), cpu_to_data);
		reader.advance();
	}
	reader.close();

	cpu_to_data.entrySet().stream()
		.sorted(Map.Entry.<Long, CpuData>comparingByKey())
		.forEach(e0 -> {
				System.out.println("CPU: "+e0.getKey());
				e0.getValue().tasktotime.entrySet().stream()
					.sorted(Map.Entry.<String, Long>comparingByValue().reversed())
					.limit(5)
					.forEach(e1 -> {
							System.out.format("\t%s: %f\n", e1.getKey(),
									  (double)e1.getValue() / 1000000000);
						});
			});
}

#include <inttypes.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include <actf/actf.h>

typedef struct fatcharp {
	const char *s;
	size_t len;
} fatcharp;

/* fnv-1a for non null-terminated fatcharps */
static inline size_t fatcharp_hash_fnv(fatcharp p)
{
	size_t prime, offset_basis;
	if (sizeof(prime) == 4) {
		prime = UINT32_C(16777619);
		offset_basis = UINT32_C(2166136261);
	} else { // assume 64-bit
		prime = UINT64_C(1099511628211);
		offset_basis = UINT64_C(14695981039346656037);
	}
	size_t hash = offset_basis;
	for (size_t i = 0; i < p.len; i++) {
		hash ^= p.s[i];
		hash *= prime;
	}
	return hash;
}

static inline int fatcharpcmp(fatcharp p1, fatcharp p2) {
	if (p1.len < p2.len) {
		return -1;
	} else if (p1.len > p2.len) {
		return 1;
	} else {
		return strncmp(p1.s, p2.s, p1.len);
	}
}

#define MAP_NAME fatcharptou64
#define MAP_KEY_TYPE fatcharp
#define MAP_KEY_CMP fatcharpcmp
#define MAP_VAL_TYPE uint64_t
#define MAP_HASH fatcharp_hash_fnv
#include "crust/map.h"

struct cpudata {
	int64_t last_tstamp;
	fatcharptou64 tasktotime;
};

static void cpudata_free(struct cpudata d)
{
	fatcharptou64_free(&d.tasktotime);
}

#define MAP_NAME u64tocpudata
#define MAP_KEY_TYPE uint64_t
#define MAP_KEY_CMP uint64cmp
#define MAP_VAL_TYPE struct cpudata
#define MAP_VAL_FREE cpudata_free
#define MAP_HASH hash_uint64
#include "crust/map.h"

void process(actf_event *ev, u64tocpudata *cputodata)
{
	const actf_event_cls *evc = actf_event_event_cls(ev);
	const char *name = actf_event_cls_name(evc);
	if (strcmp(name, "sched:sched_switch") != 0) {
		return;
	}
	int64_t tstamp = actf_event_tstamp_ns_from_origin(ev);
	uint64_t cpu_id = actf_fld_uint64(actf_pkt_fld(actf_event_pkt(ev), "cpu_id"));
	struct cpudata *data = u64tocpudata_find(cputodata, cpu_id);
	if (! data) {
		struct cpudata d;
		d.last_tstamp = tstamp;
		fatcharptou64_init_cap(&d.tasktotime, 16);
		u64tocpudata_insert(cputodata, cpu_id, d);
		data = u64tocpudata_find(cputodata, cpu_id);
	}

	const actf_fld *prev_comm_fld = actf_event_fld(ev, "prev_comm");
	fatcharp prev_comm = {
		.s = actf_fld_str_raw(prev_comm_fld),
		.len = actf_fld_str_sz(prev_comm_fld)
	};

	uint64_t diff = (uint64_t)(tstamp - data->last_tstamp);

	uint64_t *t = fatcharptou64_find(&data->tasktotime, prev_comm);
	if (t) {
		*t += diff;
	} else {
		fatcharptou64_insert(&data->tasktotime, prev_comm, diff);
	}

	data->last_tstamp = tstamp;
}

struct task {
	fatcharp name;
	uint64_t time;
};

static int tasktimecmp(const void *a0, const void *a1)
{
	const struct task *t0 = a0;
	const struct task *t1 = a1;
	if (t0->time > t1->time) {
		return -1;
	} else if (t0->time < t1->time) {
		return 1;
	} else {
		return 0;
	}
}

static int u64cmp(const void *a0, const void *a1)
{
	const uint64_t *v0 = a0;
	const uint64_t *v1 = a1;
	if (*v0 < *v1) {
		return -1;
	} else if (*v0 > *v1) {
		return 1;
	} else {
		return 0;
	}
}

int main(int argc, char *argv[])
{
	if (argc != 2) {
		fprintf(stderr, "Usage: %s <CTF_PATH>\n", argv[0]);
		return 1;
	}

	int rc = 0;
	struct actf_freader_cfg cfg = { 0 };
	actf_freader *rd = actf_freader_init(cfg);
	if (!rd) {
		perror("actf_freader_init");
		return rc;
	}
	if (actf_freader_open_folders(rd, argv + 1, argc - 1) < 0) {
		fprintf(stderr, "actf_freader_open_folder: %s\n", actf_freader_last_error(rd));
		goto err;
	}

	u64tocpudata cputodata;
	u64tocpudata_init_cap(&cputodata, 16);
	size_t evs_len = 0;
	actf_event **evs = NULL;
	while ((rc = actf_freader_read(rd, &evs, &evs_len)) == 0 && evs_len) {
		for (size_t i = 0; i < evs_len; i++) {
			process(evs[i], &cputodata);
		}
	}
	if (rc < 0) {
		fprintf(stderr, "actf_freader_read: %s\n", actf_freader_last_error(rd));
	}

	uint64_t *cpus = malloc(sizeof(*cpus) * cputodata.len);
	struct cpudata tmp;
	struct u64tocpudata_it it = { 0 };
	for (size_t i = 0; u64tocpudata_foreach(&cputodata, &cpus[i],
						&tmp, &it) == 0; i++) {};
	qsort(cpus, cputodata.len, sizeof(*cpus), u64cmp);

	for (size_t i = 0; i < cputodata.len; i++) {
		printf("CPU %"PRIu64"\n", cpus[i]);
		struct cpudata *data = u64tocpudata_find(&cputodata, cpus[i]);

		struct task *tasks = malloc(sizeof(*tasks) * data->tasktotime.len);
		struct fatcharptou64_it it = { 0 };
		for (size_t j = 0; fatcharptou64_foreach(&data->tasktotime, &tasks[j].name,
							 &tasks[j].time, &it) == 0; j++) {};

		qsort(tasks, data->tasktotime.len, sizeof(*tasks), tasktimecmp);
		for (size_t j = 0; j < data->tasktotime.len && j < 5; j++) {
			printf("%20.*s: %f s\n", (int)tasks[j].name.len, tasks[j].name.s,
			       (double)tasks[j].time / 1000000000);
		}
		free(tasks);
	}


	free(cpus);
	u64tocpudata_free(&cputodata);
err:
	actf_freader_free(rd);
	return rc;
}

use actf::Event;
use actf::EventGenerate;
use actf::Freader;
use actf::FreaderConfig;
use std::collections::HashMap;
use std::path::Path;

struct CpuData {
    last_tstamp: i64,
    task_to_time: HashMap<String, u64>,
}

impl CpuData {
    fn new(tstamp: i64) -> Self {
        Self {
            last_tstamp: tstamp,
            task_to_time: HashMap::new(),
        }
    }
}

fn process(ev: &Event, cpu_to_data: &mut HashMap<u64, CpuData>) {
    let name = ev.class().name().unwrap();
    if name != "sched:sched_switch" {
        return;
    }
    let tstamp = ev.timestamp_ns_from_origin();
    let cpu_id = ev.packet().field("cpu_id").unwrap().as_u64().unwrap();
    let data = cpu_to_data.entry(cpu_id).or_insert(CpuData::new(tstamp));

    let prev_comm_s = ev.field("prev_comm").unwrap().as_string().unwrap();
    let prev_comm = prev_comm_s.as_str().unwrap();

    let diff = (tstamp - data.last_tstamp) as u64;

    if let Some(t) = data.task_to_time.get_mut(prev_comm) {
        *t += diff;
    } else {
        data.task_to_time.insert(prev_comm.to_string(), diff);
    }

    data.last_tstamp = tstamp;
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = std::env::args().nth(1).expect("no path given");
    let mut fr = Freader::open_folder(FreaderConfig::default(), &Path::new(&path)).unwrap();

    let mut cpu_to_data: HashMap<u64, CpuData> = HashMap::new();

    while let Some(evs) = fr.generate() {
        for &ev in evs? {
            process(ev, &mut cpu_to_data);
        }
    }

    let mut cpus: Vec<(&u64, &CpuData)> = cpu_to_data.iter().collect();
    cpus.sort_by(|a, b| a.0.cmp(b.0));
    for (cpu, data) in cpus {
        println!("CPU {cpu}");
        let mut tasks: Vec<(&String, &u64)> = data.task_to_time.iter().collect();
        tasks.sort_by(|a, b| b.1.cmp(a.1));
        for &(task, &time) in tasks.iter().take(5) {
            println!("{:>20}: {} s", task, time as f64 / 1000000000.0);
        }
    }

    Ok(())
}

function actf.init(...)
   cputodata = {} -- cpu_id to {last_tstamp, tasktotime}
end

function actf.filter(ev)
   if ev:name() ~= "sched:sched_switch" then
      return nil
   end
   local cpu = ev:get("cpu_id")
   local tstamp = ev:timestamp_ns()
   local data = cputodata[cpu]
   if data == nil then
      local tasktotime = {}
      setmetatable(tasktotime, {__index = function () return 0 end})
      data = {last_tstamp=tstamp, tasktotime=tasktotime}
      cputodata[cpu] = data
   end
   local prev_comm = ev:get("prev_comm")
   local diff = tstamp - data.last_tstamp
   data.tasktotime[prev_comm] = data.tasktotime[prev_comm] + diff
   data.last_tstamp = tstamp
end

function actf.fini()
   local cpus = {}
   for k, v in pairs(cputodata) do table.insert(cpus, k) end
   table.sort(cpus)
   for _, cpu in ipairs(cpus) do
      print("CPU " .. cpu)
      local tasktimes = {}
      for k, v in pairs(cputodata[cpu].tasktotime) do table.insert(tasktimes, {k, v}) end
      table.sort(tasktimes, function (b, c) return b[2] > c[2] end)
      for i, tasktime in ipairs(tasktimes) do
	 print(string.format("%20s: %f s", tasktime[1], tasktime[2] / 1000000000))
	 if i == 5 then break end
      end
   end
end