29187058583

Committed 12 Jul 2026 09:11AM UTC coverage: 51.324% (-1.4%) from 52.754%

Build # 29187058583

Build Type

Pull #96

github

Committed by

web-flow

Commit Message

Merge 7e90b76dd into 056c79287

Pull Request Pull Request #96: fix: consolidate stale-index rebuilds across consumers and fix multi-run breaks

Coverage Stats

33807 of 84432 branches covered (40.04%)

Branch coverage included in aggregate %.

145 of 152 new or added lines in 16 files covered. (95.39%)

5186 existing lines in 197 files now uncovered.

34558 of 48770 relevant lines covered (70.86%)

10797.15 hits per line

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

52.38

/src/dftracer/utils/python/memoryview_batch.cpp

#define PY_SSIZE_T_CLEAN
#include <dftracer/utils/python/memoryview_batch.h>
#include <dftracer/utils/python/py_type_helpers.h>

#include <cstring>

namespace dftracer::utils::python {

static void MemoryViewBatch_dealloc(MemoryViewBatchObject *self) {
    delete self->data;
    Py_TYPE(self)->tp_free((PyObject *)self);
}

static int MemoryViewBatch_getbuffer(MemoryViewBatchObject *self,
                                     Py_buffer *view, int flags) {
    if (!self->data || self->data->buffer.empty()) {
        PyErr_SetString(PyExc_BufferError, "MemoryViewBatch has no data");
        return -1;
    }
    return PyBuffer_FillInfo(view, (PyObject *)self, self->data->buffer.data(),
                             static_cast<Py_ssize_t>(self->data->buffer.size()),
                             1, flags);
}

static Py_ssize_t MemoryViewBatch_length(MemoryViewBatchObject *self) {
    if (!self->data) return 0;
    return static_cast<Py_ssize_t>(self->data->num_entries());
}

PyObject *MemoryViewBatch_item(MemoryViewBatchObject *self, Py_ssize_t i) {
    if (!self->data) {
        PyErr_SetString(PyExc_IndexError, "MemoryViewBatch has no data");
        return NULL;
    }
    Py_ssize_t n = static_cast<Py_ssize_t>(self->data->num_entries());
    if (i < 0 || i >= n) {
        PyErr_SetString(PyExc_IndexError, "MemoryViewBatch index out of range");
        return NULL;
    }

    PyObject *full = PyMemoryView_FromObject((PyObject *)self);
    if (!full) return NULL;

    Py_ssize_t start = static_cast<Py_ssize_t>(self->data->offsets[i]);
    Py_ssize_t stop = start + static_cast<Py_ssize_t>(self->data->lengths[i]);
    PyObject *lo = PyLong_FromSsize_t(start);
    PyObject *hi = PyLong_FromSsize_t(stop);
    PyObject *slice = (lo && hi) ? PySlice_New(lo, hi, NULL) : NULL;
    Py_XDECREF(lo);
    Py_XDECREF(hi);
    if (!slice) {
        Py_DECREF(full);
        return NULL;
    }
    PyObject *entry = PyObject_GetItem(full, slice);  // sub-view, shares buffer
    Py_DECREF(slice);
    Py_DECREF(full);
    return entry;
}

static PyBufferProcs MemoryViewBatch_as_buffer = {
    (getbufferproc)MemoryViewBatch_getbuffer,
    NULL,
};

static PySequenceMethods MemoryViewBatch_as_sequence = {
    (lenfunc)MemoryViewBatch_length,
    NULL,
    NULL,
    (ssizeargfunc)MemoryViewBatch_item,
};

static PyObject *MemoryViewBatch_get_num_entries(MemoryViewBatchObject *self,
                                                 void *) {
    if (!self->data) return PyLong_FromLong(0);
    return PyLong_FromSsize_t(
        static_cast<Py_ssize_t>(self->data->num_entries()));
}

static PyObject *MemoryViewBatch_get_num_bytes(MemoryViewBatchObject *self,
                                               void *) {
    if (!self->data) return PyLong_FromLong(0);
    return PyLong_FromSsize_t(
        static_cast<Py_ssize_t>(self->data->buffer.size()));
}

static PyGetSetDef MemoryViewBatch_getsetters[] = {
    {"num_entries", (getter)MemoryViewBatch_get_num_entries, NULL,
     "Number of entries", NULL},
    {"num_bytes", (getter)MemoryViewBatch_get_num_bytes, NULL,
     "Total buffer size in bytes", NULL},
    {NULL}};

PyTypeObject MemoryViewBatchType = {
    .ob_base = PyVarObject_HEAD_INIT(NULL, 0).tp_name =
        "dftracer_utils_ext._MemoryViewBatch",
    .tp_basicsize = sizeof(MemoryViewBatchObject),
    .tp_itemsize = 0,
    .tp_dealloc = (destructor)MemoryViewBatch_dealloc,
    .tp_as_sequence = &MemoryViewBatch_as_sequence,
    .tp_as_buffer = &MemoryViewBatch_as_buffer,
    .tp_flags = Py_TPFLAGS_DEFAULT,
    .tp_doc = "Zero-copy batch of byte entries backed by a contiguous buffer",
    .tp_getset = MemoryViewBatch_getsetters,
};

int init_memoryview_batch(PyObject *m) {
    if (register_type(m, &MemoryViewBatchType, "_MemoryViewBatch") < 0)
        return -1;
    return 0;
}

}  // namespace dftracer::utils::python

1	#define PY_SSIZE_T_CLEAN
2	#include <dftracer/utils/python/memoryview_batch.h>
3	#include <dftracer/utils/python/py_type_helpers.h>
4
5	#include <cstring>
6
7	namespace dftracer::utils::python {
8
9	static void MemoryViewBatch_dealloc(MemoryViewBatchObject *self) {	254✔
10	delete self->data;	254!
11	Py_TYPE(self)->tp_free((PyObject *)self);	254✔
12	}	254✔
13
14	static int MemoryViewBatch_getbuffer(MemoryViewBatchObject *self,	1,191✔
15	Py_buffer *view, int flags) {
16	if (!self->data \|\| self->data->buffer.empty()) {	1,191!
17	PyErr_SetString(PyExc_BufferError, "MemoryViewBatch has no data");	×
18	return -1;	×
19	}
20	return PyBuffer_FillInfo(view, (PyObject *)self, self->data->buffer.data(),	2,382✔
21	static_cast<Py_ssize_t>(self->data->buffer.size()),	1,191✔
22	1, flags);	1,191✔
23	}	1,191✔
24
25	static Py_ssize_t MemoryViewBatch_length(MemoryViewBatchObject *self) {	×
26	if (!self->data) return 0;	×
27	return static_cast<Py_ssize_t>(self->data->num_entries());	×
UNCOV 28	}	×
29
30	PyObject MemoryViewBatch_item(MemoryViewBatchObject self, Py_ssize_t i) {	1,191✔
31	if (!self->data) {	1,191!
32	PyErr_SetString(PyExc_IndexError, "MemoryViewBatch has no data");	×
33	return NULL;	×
34	}
35	Py_ssize_t n = static_cast<Py_ssize_t>(self->data->num_entries());	1,191✔
36	if (i < 0 \|\| i >= n) {	1,191!
37	PyErr_SetString(PyExc_IndexError, "MemoryViewBatch index out of range");	×
38	return NULL;	×
39	}
40
41	PyObject full = PyMemoryView_FromObject((PyObject )self);	1,191✔
42	if (!full) return NULL;	1,191!
43
44	Py_ssize_t start = static_cast<Py_ssize_t>(self->data->offsets[i]);	1,191✔
45	Py_ssize_t stop = start + static_cast<Py_ssize_t>(self->data->lengths[i]);	1,191✔
46	PyObject *lo = PyLong_FromSsize_t(start);	1,191✔
47	PyObject *hi = PyLong_FromSsize_t(stop);	1,191✔
48	PyObject *slice = (lo && hi) ? PySlice_New(lo, hi, NULL) : NULL;	1,191!
49	Py_XDECREF(lo);	1,191✔
50	Py_XDECREF(hi);	1,191✔
51	if (!slice) {	1,191!
UNCOV 52	Py_DECREF(full);	×
53	return NULL;	×
54	}
55	PyObject *entry = PyObject_GetItem(full, slice); // sub-view, shares buffer	1,191✔
56	Py_DECREF(slice);	1,191✔
57	Py_DECREF(full);	1,191✔
58	return entry;	1,191✔
59	}	1,191✔
60
61	static PyBufferProcs MemoryViewBatch_as_buffer = {
62	(getbufferproc)MemoryViewBatch_getbuffer,
63	NULL,
64	};
65
66	static PySequenceMethods MemoryViewBatch_as_sequence = {
67	(lenfunc)MemoryViewBatch_length,
68	NULL,
69	NULL,
70	(ssizeargfunc)MemoryViewBatch_item,
71	};
72
73	static PyObject MemoryViewBatch_get_num_entries(MemoryViewBatchObject self,	×
74	void *) {
75	if (!self->data) return PyLong_FromLong(0);	×
76	return PyLong_FromSsize_t(	×
77	static_cast<Py_ssize_t>(self->data->num_entries()));	×
UNCOV 78	}	×
79
80	static PyObject MemoryViewBatch_get_num_bytes(MemoryViewBatchObject self,	×
81	void *) {
82	if (!self->data) return PyLong_FromLong(0);	×
83	return PyLong_FromSsize_t(	×
84	static_cast<Py_ssize_t>(self->data->buffer.size()));	×
UNCOV 85	}	×
86
87	static PyGetSetDef MemoryViewBatch_getsetters[] = {
88	{"num_entries", (getter)MemoryViewBatch_get_num_entries, NULL,
89	"Number of entries", NULL},
90	{"num_bytes", (getter)MemoryViewBatch_get_num_bytes, NULL,
91	"Total buffer size in bytes", NULL},
92	{NULL}};
93
94	PyTypeObject MemoryViewBatchType = {
95	.ob_base = PyVarObject_HEAD_INIT(NULL, 0).tp_name =
96	"dftracer_utils_ext._MemoryViewBatch",
97	.tp_basicsize = sizeof(MemoryViewBatchObject),
98	.tp_itemsize = 0,
99	.tp_dealloc = (destructor)MemoryViewBatch_dealloc,
100	.tp_as_sequence = &MemoryViewBatch_as_sequence,
101	.tp_as_buffer = &MemoryViewBatch_as_buffer,
102	.tp_flags = Py_TPFLAGS_DEFAULT,
103	.tp_doc = "Zero-copy batch of byte entries backed by a contiguous buffer",
104	.tp_getset = MemoryViewBatch_getsetters,
105	};
106
107	int init_memoryview_batch(PyObject *m) {	1✔
108	if (register_type(m, &MemoryViewBatchType, "_MemoryViewBatch") < 0)	1!
109	return -1;	×
110	return 0;	1✔
111	}	1✔
112
113	} // namespace dftracer::utils::python

llnl / dftracer-utils / 29187058583

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