26932094552

Committed 04 Jun 2026 05:08AM UTC coverage: 49.905% (-2.3%) from 52.184%

Build # 26932094552

Build Type

push

github

Committed by

hariharan-devarajan

Commit Message

chore(utils): add portable to_chars_double fallback for macOS and update zstd handling

- Introduce to_chars_double wrapper that falls back to snprintf on macOS < 13.3
- Force CPM-built zstd on Apple to avoid deployment target mismatches
- Update version patch to 8

Coverage Stats

16076 of 43875 branches covered (36.64%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

660 existing lines in 103 files now uncovered.

21461 of 31342 relevant lines covered (68.47%)

13056.69 hits per line

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

51.03

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

#define PY_SSIZE_T_CLEAN
#include <dftracer/utils/core/coro/task.h>
#include <dftracer/utils/core/runtime.h>
#include <dftracer/utils/python/runtime.h>
#include <dftracer/utils/python/utilities/statistics_query.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/statistics_query_utility.h>

#include <string>

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

static Runtime *get_runtime(StatisticsQueryObject *self) {
    if (self->runtime_obj)
        return ((RuntimeObject *)self->runtime_obj)->runtime.get();
    return get_default_runtime();
}

static void StatisticsQuery_dealloc(StatisticsQueryObject *self) {
    Py_XDECREF(self->runtime_obj);
    Py_TYPE(self)->tp_free((PyObject *)self);
}

static PyObject *StatisticsQuery_new(PyTypeObject *type, PyObject *args,
                                     PyObject *kwds) {
    StatisticsQueryObject *self =
        (StatisticsQueryObject *)type->tp_alloc(type, 0);
    if (self) {
        self->runtime_obj = NULL;
    }
    return (PyObject *)self;
}

static int StatisticsQuery_init(StatisticsQueryObject *self, PyObject *args,
                                PyObject *kwds) {
    static const char *kwlist[] = {"runtime", NULL};
    PyObject *runtime_arg = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", (char **)kwlist,
                                     &runtime_arg)) {
        return -1;
    }

    if (runtime_arg && runtime_arg != Py_None) {
        if (PyObject_TypeCheck(runtime_arg, &RuntimeType)) {
            Py_INCREF(runtime_arg);
            self->runtime_obj = runtime_arg;
        } else {
            PyObject *native = PyObject_GetAttrString(runtime_arg, "_native");
            if (native && PyObject_TypeCheck(native, &RuntimeType)) {
                self->runtime_obj = native;
            } else {
                Py_XDECREF(native);
                PyErr_SetString(PyExc_TypeError,
                                "runtime must be a Runtime instance or None");
                return -1;
            }
        }
    }

    return 0;
}

static PyObject *StatisticsQuery_query(StatisticsQueryObject *self,
                                       PyObject *args, PyObject *kwds) {
    static const char *kwlist[] = {"file_path", "query_type", "top_n",
                                   "index_dir", NULL};
    const char *file_path;
    const char *query_type_str = "summary";
    Py_ssize_t top_n = 10;
    const char *index_dir = "";

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|sns", (char **)kwlist,
                                     &file_path, &query_type_str, &top_n,
                                     &index_dir)) {
        return NULL;
    }

    StatisticsQueryType qt;
    if (strcmp(query_type_str, "summary") == 0) {
        qt = StatisticsQueryType::SUMMARY;
    } else if (strcmp(query_type_str, "categories") == 0) {
        qt = StatisticsQueryType::CATEGORIES;
    } else if (strcmp(query_type_str, "names") == 0) {
        qt = StatisticsQueryType::NAMES;
    } else if (strcmp(query_type_str, "pid_tids") == 0) {
        qt = StatisticsQueryType::PID_TIDS;
    } else if (strcmp(query_type_str, "time_range") == 0) {
        qt = StatisticsQueryType::TIME_RANGE;
    } else if (strcmp(query_type_str, "duration_stats") == 0) {
        qt = StatisticsQueryType::DURATION_STATS;
    } else if (strcmp(query_type_str, "top_n_names") == 0) {
        qt = StatisticsQueryType::TOP_N_NAMES;
    } else if (strcmp(query_type_str, "top_n_categories") == 0) {
        qt = StatisticsQueryType::TOP_N_CATEGORIES;
    } else if (strcmp(query_type_str, "detailed") == 0) {
        qt = StatisticsQueryType::DETAILED;
    } else {
        PyErr_Format(PyExc_ValueError, "unknown query_type: '%s'",
                     query_type_str);
        return NULL;
    }

    std::string file_path_str(file_path);
    std::string index_dir_str(index_dir);
    std::string error_msg;
    TraceStatistics stats;
    StatisticsQueryOutput output;
    auto qt_copy = qt;
    auto top_n_copy = static_cast<std::uint64_t>(top_n);

    Py_BEGIN_ALLOW_THREADS try {
        Runtime *rt = get_runtime(self);

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

        auto *stats_p = &stats;
        auto agg_task = [stats_p, agg_input]() -> CoroTask<void> {
            StatisticsAggregatorUtility util;
            *stats_p = co_await util.process(agg_input);
        };
        rt->submit(agg_task(), "stats-agg").get();

        StatisticsQueryInput query_input;
        query_input.stats = std::move(stats);
        query_input.query_type = qt_copy;
        query_input.top_n = top_n_copy;

        auto *out_p = &output;
        auto query_task = [out_p, query_input]() -> CoroTask<void> {
            StatisticsQueryUtility util;
            *out_p = co_await util.process(query_input);
        };
        rt->submit(query_task(), "stats-query").get();
    } catch (const std::exception &e) {
        error_msg = e.what();
    }
    Py_END_ALLOW_THREADS

        if (!error_msg.empty()) {
        PyErr_SetString(PyExc_RuntimeError, error_msg.c_str());
        return NULL;
    }

    PyObject *results_list =
        PyList_New(static_cast<Py_ssize_t>(output.results.size()));
    if (!results_list) return NULL;

    for (std::size_t i = 0; i < output.results.size(); ++i) {
        PyObject *tup = PyTuple_New(2);
        if (!tup) {
            Py_DECREF(results_list);
            return NULL;
        }
        PyTuple_SET_ITEM(tup, 0,
                         PyUnicode_FromString(output.results[i].first.c_str()));
        PyTuple_SET_ITEM(tup, 1,
                         PyLong_FromUnsignedLongLong(output.results[i].second));
        PyList_SET_ITEM(results_list, static_cast<Py_ssize_t>(i), tup);
    }

    PyObject *d = PyDict_New();
    if (!d) {
        Py_DECREF(results_list);
        return NULL;
    }

#define SET_STR(k, v)                                    \
    do {                                                 \
        PyObject *_v = PyUnicode_FromString(v);          \
        if (!_v || PyDict_SetItemString(d, k, _v) < 0) { \
            Py_XDECREF(_v);                              \
            Py_DECREF(results_list);                     \
            Py_DECREF(d);                                \
            return NULL;                                 \
        }                                                \
        Py_DECREF(_v);                                   \
    } while (0)

#define SET_ULL(k, v)                                    \
    do {                                                 \
        PyObject *_v = PyLong_FromUnsignedLongLong(v);   \
        if (!_v || PyDict_SetItemString(d, k, _v) < 0) { \
            Py_XDECREF(_v);                              \
            Py_DECREF(results_list);                     \
            Py_DECREF(d);                                \
            return NULL;                                 \
        }                                                \
        Py_DECREF(_v);                                   \
    } while (0)

#define SET_DBL(k, v)                                    \
    do {                                                 \
        PyObject *_v = PyFloat_FromDouble(v);            \
        if (!_v || PyDict_SetItemString(d, k, _v) < 0) { \
            Py_XDECREF(_v);                              \
            Py_DECREF(results_list);                     \
            Py_DECREF(d);                                \
            return NULL;                                 \
        }                                                \
        Py_DECREF(_v);                                   \
    } while (0)

    SET_STR("query_type", output.query_type_name.c_str());
    SET_ULL("total_events", output.total_events);
    SET_ULL("min_timestamp_us", output.min_timestamp_us);
    SET_ULL("max_timestamp_us", output.max_timestamp_us);
    SET_DBL("time_span_seconds", output.time_span_seconds);
    SET_ULL("duration_count", output.duration_count);
    SET_DBL("duration_mean_us", output.duration_mean_us);
    SET_DBL("duration_stddev_us", output.duration_stddev_us);
    SET_ULL("duration_min_us", output.duration_min_us);
    SET_ULL("duration_max_us", output.duration_max_us);

    if (PyDict_SetItemString(d, "results", results_list) < 0) {
        Py_DECREF(results_list);
        Py_DECREF(d);
        return NULL;
    }
    Py_DECREF(results_list);

#undef SET_STR
#undef SET_ULL
#undef SET_DBL

    return d;
}

static PyObject *StatisticsQuery_call(PyObject *self, PyObject *args,
                                      PyObject *kwds) {
    return StatisticsQuery_query((StatisticsQueryObject *)self, args, kwds);
}

static PyMethodDef StatisticsQuery_methods[] = {
    {"process", (PyCFunction)StatisticsQuery_query,
     METH_VARARGS | METH_KEYWORDS,
     "process(file_path, query_type='summary', top_n=10, index_dir='')\n"
     "--\n"
     "\n"
     "Query statistics from an indexed trace file.\n"
     "\n"
     "Args:\n"
     "    file_path (str): Path to the trace file.\n"
     "    query_type (str): Query type (default 'summary'). One of\n"
     "        'summary', 'categories', 'names', 'pid_tids',\n"
     "        'time_range', 'duration_stats', 'top_n_names',\n"
     "        'top_n_categories', 'detailed'.\n"
     "    top_n (int): Top results for ranked queries (default 10).\n"
     "    index_dir (str): Directory for .dftindex stores (default '').\n"
     "\n"
     "Returns:\n"
     "    dict: Query results.\n"},
    {NULL}};

PyTypeObject StatisticsQueryUtilityType = {
    PyVarObject_HEAD_INIT(
        NULL, 0) "dftracer_utils_ext.StatisticsQueryUtility", /* tp_name */
    sizeof(StatisticsQueryObject),                            /* tp_basicsize */
    0,                                                        /* tp_itemsize */
    (destructor)StatisticsQuery_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 */
    StatisticsQuery_call,                     /* tp_call */
    0,                                        /* tp_str */
    0,                                        /* tp_getattro */
    0,                                        /* tp_setattro */
    0,                                        /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
    "StatisticsQueryUtility(runtime: Runtime | None = None)\n"
    "--\n\n"
    "Query pre-computed 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 */
    StatisticsQuery_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)StatisticsQuery_init, /* tp_init */
    0,                              /* tp_alloc */
    StatisticsQuery_new,            /* tp_new */
};

int init_statistics_query(PyObject *m) {
    if (PyType_Ready(&StatisticsQueryUtilityType) < 0) return -1;

    Py_INCREF(&StatisticsQueryUtilityType);
    if (PyModule_AddObject(m, "StatisticsQueryUtility",
                           (PyObject *)&StatisticsQueryUtilityType) < 0) {
        Py_DECREF(&StatisticsQueryUtilityType);
        Py_DECREF(m);
        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/runtime.h>
5	#include <dftracer/utils/python/utilities/statistics_query.h>
6	#include <dftracer/utils/utilities/composites/dft/internal/utils.h>
7	#include <dftracer/utils/utilities/composites/dft/statistics/statistics_aggregator_utility.h>
8	#include <dftracer/utils/utilities/composites/dft/statistics/statistics_query_utility.h>
9
10	#include <string>
11
12	using dftracer::utils::Runtime;
13	using dftracer::utils::coro::CoroTask;
14	using namespace dftracer::utils::utilities::composites::dft::statistics;
15
16	static Runtime get_runtime(StatisticsQueryObject self) {	8✔
17	if (self->runtime_obj)	8!
18	return ((RuntimeObject *)self->runtime_obj)->runtime.get();	×
19	return get_default_runtime();	8✔
20	}
21
22	static void StatisticsQuery_dealloc(StatisticsQueryObject *self) {	8✔
23	Py_XDECREF(self->runtime_obj);	8✔
24	Py_TYPE(self)->tp_free((PyObject *)self);	8✔
25	}	8✔
26
27	static PyObject StatisticsQuery_new(PyTypeObject type, PyObject *args,	8✔
28	PyObject *kwds) {
29	StatisticsQueryObject *self =
30	(StatisticsQueryObject *)type->tp_alloc(type, 0);	8✔
31	if (self) {	8!
32	self->runtime_obj = NULL;	8✔
33	}
34	return (PyObject *)self;	8✔
35	}
36
37	static int StatisticsQuery_init(StatisticsQueryObject self, PyObject args,	8✔
38	PyObject *kwds) {
39	static const char *kwlist[] = {"runtime", NULL};
40	PyObject *runtime_arg = NULL;	8✔
41
42	if (!PyArg_ParseTupleAndKeywords(args, kwds, "\|O", (char **)kwlist,	8!
43	&runtime_arg)) {
44	return -1;	×
45	}
46
47	if (runtime_arg && runtime_arg != Py_None) {	8!
48	if (PyObject_TypeCheck(runtime_arg, &RuntimeType)) {	×
49	Py_INCREF(runtime_arg);	×
50	self->runtime_obj = runtime_arg;	×
51	} else {
52	PyObject *native = PyObject_GetAttrString(runtime_arg, "_native");	×
53	if (native && PyObject_TypeCheck(native, &RuntimeType)) {	×
54	self->runtime_obj = native;	×
55	} else {
56	Py_XDECREF(native);	×
57	PyErr_SetString(PyExc_TypeError,	×
58	"runtime must be a Runtime instance or None");
59	return -1;	×
60	}
61	}
62	}
63
64	return 0;	8✔
65	}
66
67	static PyObject StatisticsQuery_query(StatisticsQueryObject self,	8✔
68	PyObject args, PyObject kwds) {
69	static const char *kwlist[] = {"file_path", "query_type", "top_n",
70	"index_dir", NULL};
71	const char *file_path;
72	const char *query_type_str = "summary";	8✔
73	Py_ssize_t top_n = 10;	8✔
74	const char *index_dir = "";	8✔
75
76	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s\|sns", (char **)kwlist,	8!
77	&file_path, &query_type_str, &top_n,
78	&index_dir)) {
79	return NULL;	×
80	}
81
82	StatisticsQueryType qt;
83	if (strcmp(query_type_str, "summary") == 0) {	8✔
84	qt = StatisticsQueryType::SUMMARY;	3✔
85	} else if (strcmp(query_type_str, "categories") == 0) {	5✔
86	qt = StatisticsQueryType::CATEGORIES;	2✔
87	} else if (strcmp(query_type_str, "names") == 0) {	3✔
88	qt = StatisticsQueryType::NAMES;	1✔
89	} else if (strcmp(query_type_str, "pid_tids") == 0) {	2!
90	qt = StatisticsQueryType::PID_TIDS;	×
91	} else if (strcmp(query_type_str, "time_range") == 0) {	2!
92	qt = StatisticsQueryType::TIME_RANGE;	×
93	} else if (strcmp(query_type_str, "duration_stats") == 0) {	2✔
94	qt = StatisticsQueryType::DURATION_STATS;	1✔
95	} else if (strcmp(query_type_str, "top_n_names") == 0) {	1!
96	qt = StatisticsQueryType::TOP_N_NAMES;	1✔
UNCOV 97	} else if (strcmp(query_type_str, "top_n_categories") == 0) {	×
98	qt = StatisticsQueryType::TOP_N_CATEGORIES;	×
99	} else if (strcmp(query_type_str, "detailed") == 0) {	×
100	qt = StatisticsQueryType::DETAILED;	×
101	} else {
102	PyErr_Format(PyExc_ValueError, "unknown query_type: '%s'",	×
103	query_type_str);
104	return NULL;	×
105	}
106
107	std::string file_path_str(file_path);	8!
108	std::string index_dir_str(index_dir);	8!
109	std::string error_msg;	8✔
110	TraceStatistics stats;	8!
111	StatisticsQueryOutput output;	8✔
112	auto qt_copy = qt;	8✔
113	auto top_n_copy = static_cast<std::uint64_t>(top_n);	8✔
114
115	Py_BEGIN_ALLOW_THREADS try {	8!
116	Runtime *rt = get_runtime(self);	8!
117
118	StatisticsAggregatorInput agg_input;	8✔
119	agg_input.file_path = file_path_str;	8!
120	agg_input.index_dir = index_dir_str;	8!
121	agg_input.index_path = dftracer::utils::utilities::composites::dft::
122	internal::determine_index_path(file_path_str, index_dir_str);	8!
123
124	auto *stats_p = &stats;	8✔
125	auto agg_task = [stats_p, agg_input]() -> CoroTask<void> {	8!
126	StatisticsAggregatorUtility util;
127	*stats_p = co_await util.process(agg_input);
128	};	24!
129	rt->submit(agg_task(), "stats-agg").get();	8!
130
131	StatisticsQueryInput query_input;	8!
132	query_input.stats = std::move(stats);	8✔
133	query_input.query_type = qt_copy;	8✔
134	query_input.top_n = top_n_copy;	8✔
135
136	auto *out_p = &output;	8✔
137	auto query_task = [out_p, query_input]() -> CoroTask<void> {	8!
138	StatisticsQueryUtility util;
139	*out_p = co_await util.process(query_input);
140	};	24!
141	rt->submit(query_task(), "stats-query").get();	8!
142	} catch (const std::exception &e) {	8!
143	error_msg = e.what();	×
144	}	×
145	Py_END_ALLOW_THREADS	8!
146
147	if (!error_msg.empty()) {	8!
148	PyErr_SetString(PyExc_RuntimeError, error_msg.c_str());	×
149	return NULL;	×
150	}
151
152	PyObject *results_list =
153	PyList_New(static_cast<Py_ssize_t>(output.results.size()));	8!
154	if (!results_list) return NULL;	8!
155
156	for (std::size_t i = 0; i < output.results.size(); ++i) {	31✔
157	PyObject *tup = PyTuple_New(2);	23!
158	if (!tup) {	23!
159	Py_DECREF(results_list);
160	return NULL;	×
161	}
162	PyTuple_SET_ITEM(tup, 0,	23!
163	PyUnicode_FromString(output.results[i].first.c_str()));
164	PyTuple_SET_ITEM(tup, 1,	23!
165	PyLong_FromUnsignedLongLong(output.results[i].second));
166	PyList_SET_ITEM(results_list, static_cast<Py_ssize_t>(i), tup);	23✔
167	}
168
169	PyObject *d = PyDict_New();	8!
170	if (!d) {	8!
171	Py_DECREF(results_list);
172	return NULL;	×
173	}
174
175	#define SET_STR(k, v) \
176	do { \
177	PyObject *_v = PyUnicode_FromString(v); \
178	if (!_v \|\| PyDict_SetItemString(d, k, _v) < 0) { \
179	Py_XDECREF(_v); \
180	Py_DECREF(results_list); \
181	Py_DECREF(d); \
182	return NULL; \
183	} \
184	Py_DECREF(_v); \
185	} while (0)
186
187	#define SET_ULL(k, v) \
188	do { \
189	PyObject *_v = PyLong_FromUnsignedLongLong(v); \
190	if (!_v \|\| PyDict_SetItemString(d, k, _v) < 0) { \
191	Py_XDECREF(_v); \
192	Py_DECREF(results_list); \
193	Py_DECREF(d); \
194	return NULL; \
195	} \
196	Py_DECREF(_v); \
197	} while (0)
198
199	#define SET_DBL(k, v) \
200	do { \
201	PyObject *_v = PyFloat_FromDouble(v); \
202	if (!_v \|\| PyDict_SetItemString(d, k, _v) < 0) { \
203	Py_XDECREF(_v); \
204	Py_DECREF(results_list); \
205	Py_DECREF(d); \
206	return NULL; \
207	} \
208	Py_DECREF(_v); \
209	} while (0)
210
211	SET_STR("query_type", output.query_type_name.c_str());	8!
212	SET_ULL("total_events", output.total_events);	8!
213	SET_ULL("min_timestamp_us", output.min_timestamp_us);	8!
214	SET_ULL("max_timestamp_us", output.max_timestamp_us);	8!
215	SET_DBL("time_span_seconds", output.time_span_seconds);	8!
216	SET_ULL("duration_count", output.duration_count);	8!
217	SET_DBL("duration_mean_us", output.duration_mean_us);	8!
218	SET_DBL("duration_stddev_us", output.duration_stddev_us);	8!
219	SET_ULL("duration_min_us", output.duration_min_us);	8!
220	SET_ULL("duration_max_us", output.duration_max_us);	8!
221
222	if (PyDict_SetItemString(d, "results", results_list) < 0) {	8!
223	Py_DECREF(results_list);
224	Py_DECREF(d);
225	return NULL;	×
226	}
227	Py_DECREF(results_list);
228
229	#undef SET_STR
230	#undef SET_ULL
231	#undef SET_DBL
232
233	return d;	8✔
234	}	8✔
235
236	static PyObject StatisticsQuery_call(PyObject self, PyObject *args,	1✔
237	PyObject *kwds) {
238	return StatisticsQuery_query((StatisticsQueryObject *)self, args, kwds);	1✔
239	}
240
241	static PyMethodDef StatisticsQuery_methods[] = {
242	{"process", (PyCFunction)StatisticsQuery_query,
243	METH_VARARGS \| METH_KEYWORDS,
244	"process(file_path, query_type='summary', top_n=10, index_dir='')\n"
245	"--\n"
246	"\n"
247	"Query statistics from an indexed trace file.\n"
248	"\n"
249	"Args:\n"
250	" file_path (str): Path to the trace file.\n"
251	" query_type (str): Query type (default 'summary'). One of\n"
252	" 'summary', 'categories', 'names', 'pid_tids',\n"
253	" 'time_range', 'duration_stats', 'top_n_names',\n"
254	" 'top_n_categories', 'detailed'.\n"
255	" top_n (int): Top results for ranked queries (default 10).\n"
256	" index_dir (str): Directory for .dftindex stores (default '').\n"
257	"\n"
258	"Returns:\n"
259	" dict: Query results.\n"},
260	{NULL}};
261
262	PyTypeObject StatisticsQueryUtilityType = {
263	PyVarObject_HEAD_INIT(
264	NULL, 0) "dftracer_utils_ext.StatisticsQueryUtility", /* tp_name */
265	sizeof(StatisticsQueryObject), /* tp_basicsize */
266	0, /* tp_itemsize */
267	(destructor)StatisticsQuery_dealloc, /* tp_dealloc */
268	0, /* tp_vectorcall_offset */
269	0, /* tp_getattr */
270	0, /* tp_setattr */
271	0, /* tp_as_async */
272	0, /* tp_repr */
273	0, /* tp_as_number */
274	0, /* tp_as_sequence */
275	0, /* tp_as_mapping */
276	0, /* tp_hash */
277	StatisticsQuery_call, /* tp_call */
278	0, /* tp_str */
279	0, /* tp_getattro */
280	0, /* tp_setattro */
281	0, /* tp_as_buffer */
282	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /* tp_flags */
283	"StatisticsQueryUtility(runtime: Runtime \| None = None)\n"
284	"--\n\n"
285	"Query pre-computed statistics from an indexed trace file.\n\n"
286	"Args:\n"
287	" runtime (Runtime or None): Runtime for thread pool control.\n",
288	0, /* tp_traverse */
289	0, /* tp_clear */
290	0, /* tp_richcompare */
291	0, /* tp_weaklistoffset */
292	0, /* tp_iter */
293	0, /* tp_iternext */
294	StatisticsQuery_methods, /* tp_methods */
295	0, /* tp_members */
296	0, /* tp_getset */
297	0, /* tp_base */
298	0, /* tp_dict */
299	0, /* tp_descr_get */
300	0, /* tp_descr_set */
301	0, /* tp_dictoffset */
302	(initproc)StatisticsQuery_init, /* tp_init */
303	0, /* tp_alloc */
304	StatisticsQuery_new, /* tp_new */
305	};
306
307	int init_statistics_query(PyObject *m) {	1✔
308	if (PyType_Ready(&StatisticsQueryUtilityType) < 0) return -1;	1!
309
310	Py_INCREF(&StatisticsQueryUtilityType);
311	if (PyModule_AddObject(m, "StatisticsQueryUtility",	1✔
312	(PyObject *)&StatisticsQueryUtilityType) < 0) {	1!
313	Py_DECREF(&StatisticsQueryUtilityType);
314	Py_DECREF(m);
315	return -1;	×
316	}
317
318	return 0;	1✔
319	}

llnl / dftracer-utils / 26932094552

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