28356348514

Committed 29 Jun 2026 07:40AM UTC coverage: 52.174% (-0.1%) from 52.278%

Build # 28356348514

Build Type

Pull #83

github

Committed by

web-flow

Commit Message

Merge 278203630 into 2efed6649

Pull Request Pull Request #83: refactor and improve code QoL

Coverage Stats

37276 of 92891 branches covered (40.13%)

Branch coverage included in aggregate %.

671 of 1173 new or added lines in 58 files covered. (57.2%)

66 existing lines in 30 files now uncovered.

33619 of 42991 relevant lines covered (78.2%)

20387.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.19

/src/dftracer/utils/python/utilities/statistics_aggregator.cpp

#define PY_SSIZE_T_CLEAN
#include <dftracer/utils/core/coro/task.h>
#include <dftracer/utils/core/runtime.h>
#include <dftracer/utils/python/py_dict_helpers.h>
#include <dftracer/utils/python/py_runtime_mixin.h>
#include <dftracer/utils/python/py_type_helpers.h>
#include <dftracer/utils/python/runtime.h>
#include <dftracer/utils/python/utilities/statistics_aggregator.h>
#include <dftracer/utils/utilities/composites/dft/internal/utils.h>
#include <dftracer/utils/utilities/composites/dft/statistics/statistics_aggregator_utility.h>
#include <dftracer/utils/utilities/composites/dft/statistics/trace_statistics.h>

#include <string>

using dftracer::utils::Runtime;
using dftracer::utils::coro::CoroTask;
using namespace dftracer::utils::utilities::composites::dft::statistics;

static Runtime *get_runtime(StatisticsAggregatorObject *self) {
    return resolve_runtime(self);
}

static void StatisticsAggregator_dealloc(StatisticsAggregatorObject *self) {
    runtime_backed_dealloc(self);
}

static PyObject *StatisticsAggregator_new(PyTypeObject *type, PyObject *args,
                                          PyObject *kwds) {
    return runtime_backed_new<StatisticsAggregatorObject>(type, args, kwds);
}

static int StatisticsAggregator_init(StatisticsAggregatorObject *self,
                                     PyObject *args, PyObject *kwds) {
    return runtime_backed_init(self, args, kwds);
}

static PyObject *StatisticsAggregator_compute(StatisticsAggregatorObject *self,
                                              PyObject *args, PyObject *kwds) {
    static const char *kwlist[] = {"file_path", "index_dir", NULL};
    const char *file_path;
    const char *index_dir = "";
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|s", (char **)kwlist,
                                     &file_path, &index_dir))
        return NULL;

    std::string file_path_str(file_path);
    std::string index_dir_str(index_dir);
    TraceStatistics stats;

    if (!run_blocking([&] {
            Runtime *rt = get_runtime(self);

            StatisticsAggregatorInput input;
            input.file_path = file_path_str;
            input.index_dir = index_dir_str;
            input.index_path = dftracer::utils::utilities::composites::dft::
                internal::determine_index_path(file_path_str, index_dir_str);

            auto *stats_p = &stats;
            auto input_copy = input;
            auto task = [stats_p, input_copy]() -> CoroTask<void> {
                StatisticsAggregatorUtility util;
                *stats_p = co_await util.process(input_copy);
            };
            rt->submit(task(), "stats-aggregator").get();
        })) {
        return NULL;
    }

    PyObject *d = PyDict_New();
    if (!d) return NULL;

    int rc = 0;
    rc |= dict_set_str(d, "file_path", stats.file_path.c_str());
    rc |= dict_set_u64(d, "total_events", stats.total_events());
    rc |= dict_set_u64(d, "num_chunks", stats.num_chunks);
    rc |= dict_set_bool(d, "success", stats.success);
    rc |= dict_set_str(d, "error_message", stats.error_message.c_str());
    rc |= dict_set_f64(d, "time_span_seconds", stats.time_span_seconds());
    rc |= dict_set_f64(d, "duration_mean_us", stats.duration_mean_us());
    rc |= dict_set_f64(d, "duration_stddev_us", stats.duration_stddev_us());
    rc |= dict_set_size(d, "num_categories", stats.num_categories());
    rc |= dict_set_size(d, "num_unique_names", stats.num_unique_names());
    rc |= dict_set_size(d, "num_pid_tids", stats.num_pid_tids());
    rc |= dict_set_u64(d, "min_timestamp_us", stats.merged.min_timestamp_us);
    rc |= dict_set_u64(d, "max_timestamp_us", stats.merged.max_timestamp_us);

    if (rc != 0) {
        Py_DECREF(d);
        return NULL;
    }

    return d;
}

static PyObject *StatisticsAggregator_call(PyObject *self, PyObject *args,
                                           PyObject *kwds) {
    return StatisticsAggregator_compute((StatisticsAggregatorObject *)self,
                                        args, kwds);
}

static PyMethodDef StatisticsAggregator_methods[] = {
    {"process", (PyCFunction)StatisticsAggregator_compute,
     METH_VARARGS | METH_KEYWORDS,
     "process(file_path, index_dir='')\n"
     "--\n"
     "\n"
     "Compute aggregated statistics from a trace file.\n"
     "\n"
     "Args:\n"
     "    file_path (str): Path to the trace file.\n"
     "    index_dir (str): Directory for .dftindex stores (default '').\n"
     "\n"
     "Returns:\n"
     "    dict: Aggregated statistics.\n"},
    {NULL}};

PyTypeObject StatisticsAggregatorType = {
    PyVarObject_HEAD_INIT(
        NULL, 0) "dftracer_utils_ext.StatisticsAggregatorUtility", /* tp_name */
    sizeof(StatisticsAggregatorObject),       /* tp_basicsize */
    0,                                        /* tp_itemsize */
    (destructor)StatisticsAggregator_dealloc, /* tp_dealloc */
    0,                                        /* tp_vectorcall_offset */
    0,                                        /* tp_getattr */
    0,                                        /* tp_setattr */
    0,                                        /* tp_as_async */
    0,                                        /* tp_repr */
    0,                                        /* tp_as_number */
    0,                                        /* tp_as_sequence */
    0,                                        /* tp_as_mapping */
    0,                                        /* tp_hash */
    StatisticsAggregator_call,                /* tp_call */
    0,                                        /* tp_str */
    0,                                        /* tp_getattro */
    0,                                        /* tp_setattro */
    0,                                        /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
    "StatisticsAggregatorUtility(runtime: Runtime | None = None)\n"
    "--\n\n"
    "Aggregate statistics from an indexed trace file.\n\n"
    "Args:\n"
    "    runtime (Runtime or None): Runtime for thread pool control.\n",
    0,                                   /* tp_traverse */
    0,                                   /* tp_clear */
    0,                                   /* tp_richcompare */
    0,                                   /* tp_weaklistoffset */
    0,                                   /* tp_iter */
    0,                                   /* tp_iternext */
    StatisticsAggregator_methods,        /* tp_methods */
    0,                                   /* tp_members */
    0,                                   /* tp_getset */
    0,                                   /* tp_base */
    0,                                   /* tp_dict */
    0,                                   /* tp_descr_get */
    0,                                   /* tp_descr_set */
    0,                                   /* tp_dictoffset */
    (initproc)StatisticsAggregator_init, /* tp_init */
    0,                                   /* tp_alloc */
    StatisticsAggregator_new,            /* tp_new */
};

int init_statistics_aggregator(PyObject *m) {
    if (register_type(m, &StatisticsAggregatorType,
                      "StatisticsAggregatorUtility") < 0)
        return -1;

    return 0;
}

1	#define PY_SSIZE_T_CLEAN
2	#include <dftracer/utils/core/coro/task.h>
3	#include <dftracer/utils/core/runtime.h>
4	#include <dftracer/utils/python/py_dict_helpers.h>
5	#include <dftracer/utils/python/py_runtime_mixin.h>
6	#include <dftracer/utils/python/py_type_helpers.h>
7	#include <dftracer/utils/python/runtime.h>
8	#include <dftracer/utils/python/utilities/statistics_aggregator.h>
9	#include <dftracer/utils/utilities/composites/dft/internal/utils.h>
10	#include <dftracer/utils/utilities/composites/dft/statistics/statistics_aggregator_utility.h>
11	#include <dftracer/utils/utilities/composites/dft/statistics/trace_statistics.h>
12
13	#include <string>
14
15	using dftracer::utils::Runtime;
16	using dftracer::utils::coro::CoroTask;
17	using namespace dftracer::utils::utilities::composites::dft::statistics;
18
19	static Runtime get_runtime(StatisticsAggregatorObject self) {	14✔
20	return resolve_runtime(self);	14✔
21	}
22
23	static void StatisticsAggregator_dealloc(StatisticsAggregatorObject *self) {	14✔
24	runtime_backed_dealloc(self);	14✔
25	}	14✔
26
27	static PyObject StatisticsAggregator_new(PyTypeObject type, PyObject *args,	14✔
28	PyObject *kwds) {
29	return runtime_backed_new<StatisticsAggregatorObject>(type, args, kwds);	14✔
30	}
31
32	static int StatisticsAggregator_init(StatisticsAggregatorObject *self,	14✔
33	PyObject args, PyObject kwds) {
34	return runtime_backed_init(self, args, kwds);	14✔
35	}
36
37	static PyObject StatisticsAggregator_compute(StatisticsAggregatorObject self,	14✔
38	PyObject args, PyObject kwds) {
39	static const char *kwlist[] = {"file_path", "index_dir", NULL};
40	const char *file_path;
41	const char *index_dir = "";	14✔
42	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s\|s", (char **)kwlist,	14!
43	&file_path, &index_dir))
44	return NULL;	×
45
46	std::string file_path_str(file_path);	14!
47	std::string index_dir_str(index_dir);	14!
48	TraceStatistics stats;	14!
49
50	if (!run_blocking([&] {	21!
51	Runtime *rt = get_runtime(self);	14!
52
53	StatisticsAggregatorInput input;	14✔
54	input.file_path = file_path_str;	14!
55	input.index_dir = index_dir_str;	14!
56	input.index_path = dftracer::utils::utilities::composites::dft::	7!
57	internal::determine_index_path(file_path_str, index_dir_str);	14!
58
59	auto *stats_p = &stats;	14✔
60	auto input_copy = input;	14!
61	auto task = [stats_p, input_copy]() -> CoroTask<void> {	63!
62	StatisticsAggregatorUtility util;	21!
63	*stats_p = co_await util.process(input_copy);	28!
64	};	42!
65	rt->submit(task(), "stats-aggregator").get();	14!
66	})) {	14✔
UNCOV 67	return NULL;	×
68	}
69
70	PyObject *d = PyDict_New();	14!
71	if (!d) return NULL;	14✔
72
73	int rc = 0;	14✔
74	rc \|= dict_set_str(d, "file_path", stats.file_path.c_str());	14!
75	rc \|= dict_set_u64(d, "total_events", stats.total_events());	14!
76	rc \|= dict_set_u64(d, "num_chunks", stats.num_chunks);	14!
77	rc \|= dict_set_bool(d, "success", stats.success);	14!
78	rc \|= dict_set_str(d, "error_message", stats.error_message.c_str());	14!
79	rc \|= dict_set_f64(d, "time_span_seconds", stats.time_span_seconds());	14!
80	rc \|= dict_set_f64(d, "duration_mean_us", stats.duration_mean_us());	14!
81	rc \|= dict_set_f64(d, "duration_stddev_us", stats.duration_stddev_us());	14!
82	rc \|= dict_set_size(d, "num_categories", stats.num_categories());	14!
83	rc \|= dict_set_size(d, "num_unique_names", stats.num_unique_names());	14!
84	rc \|= dict_set_size(d, "num_pid_tids", stats.num_pid_tids());	14!
85	rc \|= dict_set_u64(d, "min_timestamp_us", stats.merged.min_timestamp_us);	14!
86	rc \|= dict_set_u64(d, "max_timestamp_us", stats.merged.max_timestamp_us);	14!
87
88	if (rc != 0) {	14!
89	Py_DECREF(d);	×
NEW 90	return NULL;	×
91	}
92
93	return d;	14✔
94	}	14✔
95
96	static PyObject StatisticsAggregator_call(PyObject self, PyObject *args,	2✔
97	PyObject *kwds) {
98	return StatisticsAggregator_compute((StatisticsAggregatorObject *)self,	3✔
99	args, kwds);	2✔
100	}
101
102	static PyMethodDef StatisticsAggregator_methods[] = {
103	{"process", (PyCFunction)StatisticsAggregator_compute,
104	METH_VARARGS \| METH_KEYWORDS,
105	"process(file_path, index_dir='')\n"
106	"--\n"
107	"\n"
108	"Compute aggregated statistics from a trace file.\n"
109	"\n"
110	"Args:\n"
111	" file_path (str): Path to the trace file.\n"
112	" index_dir (str): Directory for .dftindex stores (default '').\n"
113	"\n"
114	"Returns:\n"
115	" dict: Aggregated statistics.\n"},
116	{NULL}};
117
118	PyTypeObject StatisticsAggregatorType = {
119	PyVarObject_HEAD_INIT(
120	NULL, 0) "dftracer_utils_ext.StatisticsAggregatorUtility", /* tp_name */
121	sizeof(StatisticsAggregatorObject), /* tp_basicsize */
122	0, /* tp_itemsize */
123	(destructor)StatisticsAggregator_dealloc, /* tp_dealloc */
124	0, /* tp_vectorcall_offset */
125	0, /* tp_getattr */
126	0, /* tp_setattr */
127	0, /* tp_as_async */
128	0, /* tp_repr */
129	0, /* tp_as_number */
130	0, /* tp_as_sequence */
131	0, /* tp_as_mapping */
132	0, /* tp_hash */
133	StatisticsAggregator_call, /* tp_call */
134	0, /* tp_str */
135	0, /* tp_getattro */
136	0, /* tp_setattro */
137	0, /* tp_as_buffer */
138	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /* tp_flags */
139	"StatisticsAggregatorUtility(runtime: Runtime \| None = None)\n"
140	"--\n\n"
141	"Aggregate statistics from an indexed trace file.\n\n"
142	"Args:\n"
143	" runtime (Runtime or None): Runtime for thread pool control.\n",
144	0, /* tp_traverse */
145	0, /* tp_clear */
146	0, /* tp_richcompare */
147	0, /* tp_weaklistoffset */
148	0, /* tp_iter */
149	0, /* tp_iternext */
150	StatisticsAggregator_methods, /* tp_methods */
151	0, /* tp_members */
152	0, /* tp_getset */
153	0, /* tp_base */
154	0, /* tp_dict */
155	0, /* tp_descr_get */
156	0, /* tp_descr_set */
157	0, /* tp_dictoffset */
158	(initproc)StatisticsAggregator_init, /* tp_init */
159	0, /* tp_alloc */
160	StatisticsAggregator_new, /* tp_new */
161	};
162
163	int init_statistics_aggregator(PyObject *m) {	2✔
164	if (register_type(m, &StatisticsAggregatorType,	2✔
165	"StatisticsAggregatorUtility") < 0)	2✔
UNCOV 166	return -1;	×
167
168	return 0;	2✔
169	}	1✔

llnl / dftracer-utils / 28356348514

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous