23529483807

Committed 25 Mar 2026 07:17AM UTC coverage: 48.515% (-1.6%) from 50.098%

Build # 23529483807

Build Type

Pull #57

github

Committed by

web-flow

Commit Message

Merge 5b1e117ad into 38f9f3616

Pull Request Pull Request #57: feat(comparator): add pairwise traces comparator

Coverage Stats

18829 of 49412 branches covered (38.11%)

Branch coverage included in aggregate %.

1584 of 1933 new or added lines in 14 files covered. (81.95%)

3552 existing lines in 135 files now uncovered.

18474 of 27477 relevant lines covered (67.23%)

241072.53 hits per line

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

55.84

/src/dftracer/utils/utilities/reader/internal/reader_c.cpp

#include <dftracer/utils/core/common/logging.h>
#include <dftracer/utils/utilities/reader/internal/reader.h>
#include <dftracer/utils/utilities/reader/internal/reader_factory.h>
#include <dftracer/utils/utilities/reader/internal/stream.h>
#include <dftracer/utils/utilities/reader/internal/stream_type.h>

#include <cstring>

using namespace dftracer::utils::utilities::reader::internal;

static std::shared_ptr<Reader> *cast_reader(dft_reader_handle_t reader) {
    return static_cast<std::shared_ptr<Reader> *>(reader);
}

extern "C" {

// Helper functions for C API
static int validate_handle(dft_reader_handle_t reader) {
    return reader ? 0 : -1;
}

dft_reader_handle_t dft_reader_create(const char *gz_path, const char *idx_path,
                                      size_t index_ckpt_size) {
    if (!gz_path || !idx_path) {
        DFTRACER_UTILS_LOG_ERROR("%s",
                                 "Both gz_path and idx_path cannot be null");
        return nullptr;
    }

    try {
        auto reader = ReaderFactory::create(gz_path, idx_path, index_ckpt_size);
        // For C API, we need to transfer ownership - create a new shared_ptr on
        // heap
        return static_cast<dft_reader_handle_t>(
            new std::shared_ptr<Reader>(reader));
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to create DFT reader: %s", e.what());
        return nullptr;
    }
}

dft_reader_handle_t dft_reader_create_with_indexer(
    dft_indexer_handle_t indexer) {
    if (!indexer) {
        DFTRACER_UTILS_LOG_ERROR("%s", "Indexer cannot be null");
        return nullptr;
    }

    DFTRACER_UTILS_LOG_DEBUG("%s", "Creating DFT reader with provided indexer");

    try {
        // Indexer handle is now a shared_ptr<Indexer>*
        auto indexer_ptr = static_cast<std::shared_ptr<
            dftracer::utils::utilities::indexer::internal::Indexer> *>(indexer);
        auto reader = ReaderFactory::create(*indexer_ptr);
        return static_cast<dft_reader_handle_t>(
            new std::shared_ptr<Reader>(reader));
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to create DFT reader with indexer: %s",
                                 e.what());
        return nullptr;
    }
}

void dft_reader_destroy(dft_reader_handle_t reader) {
    if (reader) {
        delete cast_reader(reader);
    }
}

int dft_reader_get_max_bytes(dft_reader_handle_t reader, size_t *max_bytes) {
    if (validate_handle(reader) || !max_bytes) {
        return -1;
    }

    try {
        *max_bytes = (*cast_reader(reader))->get_max_bytes();
        return 0;
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to get max bytes: %s", e.what());
        return -1;
    }
}

int dft_reader_get_num_lines(dft_reader_handle_t reader, size_t *num_lines) {
    if (validate_handle(reader) || !num_lines) {
        return -1;
    }

    try {
        *num_lines = (*cast_reader(reader))->get_num_lines();
        return 0;
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to get number of lines: %s", e.what());
        return -1;
    }
}

int dft_reader_read(dft_reader_handle_t reader, size_t start_bytes,
                    size_t end_bytes, char *buffer, size_t buffer_size) {
    if (validate_handle(reader) || !buffer || buffer_size == 0) {
        return -1;
    }

    try {
        size_t bytes_read =
            (*cast_reader(reader))
                ->read(start_bytes, end_bytes, buffer, buffer_size);
        return static_cast<int>(bytes_read);
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to read: %s", e.what());
        return -1;
    }
}

int dft_reader_read_line_bytes(dft_reader_handle_t reader, size_t start_bytes,
                               size_t end_bytes, char *buffer,
                               size_t buffer_size) {
    if (validate_handle(reader) || !buffer || buffer_size == 0) {
        return -1;
    }

    try {
        size_t bytes_read =
            (*cast_reader(reader))
                ->read_line_bytes(start_bytes, end_bytes, buffer, buffer_size);
        return static_cast<int>(bytes_read);
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to read line bytes: %s", e.what());
        return -1;
    }
}

int dft_reader_read_lines(dft_reader_handle_t reader, size_t start_line,
                          size_t end_line, char *buffer, size_t buffer_size,
                          size_t *bytes_written) {
    if (validate_handle(reader) || !buffer || buffer_size == 0 ||
        !bytes_written) {
        return -1;
    }

    try {
        std::string result =
            (*cast_reader(reader))->read_lines(start_line, end_line);

        size_t result_size = result.size();
        if (result_size >= buffer_size) {
            *bytes_written = result_size;
            return -1;
        }

        std::memcpy(buffer, result.c_str(), result_size);
        buffer[result_size] = '\0';
        *bytes_written = result_size;

        return 0;
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to read lines: %s", e.what());
        *bytes_written = 0;
        return -1;
    }
}

void dft_reader_reset(dft_reader_handle_t reader) {
    if (reader) {
        (*cast_reader(reader))->reset();
    }
}

dft_reader_stream_t dft_reader_stream(dft_reader_handle_t reader,
                                      const dft_stream_config_t *config) {
    if (validate_handle(reader)) {
        DFTRACER_UTILS_LOG_ERROR("%s", "Invalid reader handle");
        return nullptr;
    }

    if (!config) {
        DFTRACER_UTILS_LOG_ERROR("%s", "Invalid config pointer");
        return nullptr;
    }

    try {
        // Convert C config to C++ config
        StreamConfig cpp_config = StreamConfig::from_c(*config);

        // Create stream
        auto stream = (*cast_reader(reader))->stream(cpp_config);

        // Transfer ownership to C API
        return static_cast<dft_reader_stream_t>(stream.release());
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to create stream: %s", e.what());
        return nullptr;
    }
}

}  // extern "C"

1	#include <dftracer/utils/core/common/logging.h>
2	#include <dftracer/utils/utilities/reader/internal/reader.h>
3	#include <dftracer/utils/utilities/reader/internal/reader_factory.h>
4	#include <dftracer/utils/utilities/reader/internal/stream.h>
5	#include <dftracer/utils/utilities/reader/internal/stream_type.h>
6
7	#include <cstring>
8
9	using namespace dftracer::utils::utilities::reader::internal;
10
11	static std::shared_ptr<Reader> *cast_reader(dft_reader_handle_t reader) {	206✔
12	return static_cast<std::shared_ptr<Reader> *>(reader);	206✔
13	}
14
15	extern "C" {
16
17	// Helper functions for C API
18	static int validate_handle(dft_reader_handle_t reader) {	186✔
19	return reader ? 0 : -1;	186✔
20	}
21
22	dft_reader_handle_t dft_reader_create(const char gz_path, const char idx_path,	12✔
23	size_t index_ckpt_size) {
24	if (!gz_path \|\| !idx_path) {	12✔
25	DFTRACER_UTILS_LOG_ERROR("%s",	2!
26	"Both gz_path and idx_path cannot be null");
27	return nullptr;	2✔
28	}
29
30	try {
31	auto reader = ReaderFactory::create(gz_path, idx_path, index_ckpt_size);	10!
32	// For C API, we need to transfer ownership - create a new shared_ptr on
33	// heap
34	return static_cast<dft_reader_handle_t>(	9✔
35	new std::shared_ptr<Reader>(reader));	9!
36	} catch (const std::exception &e) {	10!
37	DFTRACER_UTILS_LOG_ERROR("Failed to create DFT reader: %s", e.what());	1!
38	return nullptr;	1✔
39	}	1!
40	}	13✔
41
42	dft_reader_handle_t dft_reader_create_with_indexer(	22✔
43	dft_indexer_handle_t indexer) {
44	if (!indexer) {	22!
45	DFTRACER_UTILS_LOG_ERROR("%s", "Indexer cannot be null");	×
46	return nullptr;	×
47	}
48
49	DFTRACER_UTILS_LOG_DEBUG("%s", "Creating DFT reader with provided indexer");
50
51	try {
52	// Indexer handle is now a shared_ptr<Indexer>*
53	auto indexer_ptr = static_cast<std::shared_ptr<	22✔
54	dftracer::utils::utilities::indexer::internal::Indexer> *>(indexer);	22✔
55	auto reader = ReaderFactory::create(*indexer_ptr);	22!
56	return static_cast<dft_reader_handle_t>(	22✔
57	new std::shared_ptr<Reader>(reader));	22!
58	} catch (const std::exception &e) {	22!
59	DFTRACER_UTILS_LOG_ERROR("Failed to create DFT reader with indexer: %s",	×
60	e.what());
61	return nullptr;	×
62	}	×
63	}	22✔
64
65	void dft_reader_destroy(dft_reader_handle_t reader) {	31✔
66	if (reader) {	31!
67	delete cast_reader(reader);	31!
68	}	31✔
69	}	31✔
70
71	int dft_reader_get_max_bytes(dft_reader_handle_t reader, size_t *max_bytes) {	6✔
72	if (validate_handle(reader) \|\| !max_bytes) {	6✔
73	return -1;	2✔
74	}
75
76	try {
77	max_bytes = (cast_reader(reader))->get_max_bytes();	4!
78	return 0;	4✔
79	} catch (const std::exception &e) {	×
80	DFTRACER_UTILS_LOG_ERROR("Failed to get max bytes: %s", e.what());	×
81	return -1;	×
82	}	×
83	}	6✔
84
85	int dft_reader_get_num_lines(dft_reader_handle_t reader, size_t *num_lines) {	5✔
86	if (validate_handle(reader) \|\| !num_lines) {	5!
87	return -1;	×
88	}
89
90	try {
91	num_lines = (cast_reader(reader))->get_num_lines();	5!
92	return 0;	5✔
93	} catch (const std::exception &e) {	×
94	DFTRACER_UTILS_LOG_ERROR("Failed to get number of lines: %s", e.what());	×
95	return -1;	×
96	}	×
97	}	5✔
98
99	int dft_reader_read(dft_reader_handle_t reader, size_t start_bytes,	32✔
100	size_t end_bytes, char *buffer, size_t buffer_size) {
101	if (validate_handle(reader) \|\| !buffer \|\| buffer_size == 0) {	32✔
102	return -1;	5✔
103	}
104
105	try {
106	size_t bytes_read =	22✔
107	(*cast_reader(reader))	27!
108	->read(start_bytes, end_bytes, buffer, buffer_size);	27✔
109	return static_cast<int>(bytes_read);	22✔
110	} catch (const std::exception &e) {	5!
111	DFTRACER_UTILS_LOG_ERROR("Failed to read: %s", e.what());	5!
112	return -1;	5✔
113	}	5!
114	}	37✔
115
116	int dft_reader_read_line_bytes(dft_reader_handle_t reader, size_t start_bytes,	113✔
117	size_t end_bytes, char *buffer,
118	size_t buffer_size) {
119	if (validate_handle(reader) \|\| !buffer \|\| buffer_size == 0) {	113!
120	return -1;	×
121	}
122
123	try {
124	size_t bytes_read =	113✔
125	(*cast_reader(reader))	113!
126	->read_line_bytes(start_bytes, end_bytes, buffer, buffer_size);	113!
127	return static_cast<int>(bytes_read);	113✔
128	} catch (const std::exception &e) {	×
129	DFTRACER_UTILS_LOG_ERROR("Failed to read line bytes: %s", e.what());	×
130	return -1;	×
131	}	×
132	}	113✔
133
134	int dft_reader_read_lines(dft_reader_handle_t reader, size_t start_line,	14✔
135	size_t end_line, char *buffer, size_t buffer_size,
136	size_t *bytes_written) {
137	if (validate_handle(reader) \|\| !buffer \|\| buffer_size == 0 \|\|	14✔
138	!bytes_written) {	11✔
139	return -1;	4✔
140	}
141
142	try {
143	std::string result =
144	(*cast_reader(reader))->read_lines(start_line, end_line);	10!
145
146	size_t result_size = result.size();	7✔
147	if (result_size >= buffer_size) {	7✔
148	*bytes_written = result_size;	1✔
149	return -1;	1✔
150	}
151
152	std::memcpy(buffer, result.c_str(), result_size);	6✔
153	buffer[result_size] = '\0';	6✔
154	*bytes_written = result_size;	6✔
155
156	return 0;	6✔
157	} catch (const std::exception &e) {	10!
158	DFTRACER_UTILS_LOG_ERROR("Failed to read lines: %s", e.what());	3!
159	*bytes_written = 0;	3✔
160	return -1;	3✔
161	}	3!
162	}	17✔
163
164	void dft_reader_reset(dft_reader_handle_t reader) {	×
165	if (reader) {	×
166	(*cast_reader(reader))->reset();	×
UNCOV 167	}	×
168	}	×
169
170	dft_reader_stream_t dft_reader_stream(dft_reader_handle_t reader,	16✔
171	const dft_stream_config_t *config) {
172	if (validate_handle(reader)) {	16!
173	DFTRACER_UTILS_LOG_ERROR("%s", "Invalid reader handle");	×
174	return nullptr;	×
175	}
176
177	if (!config) {	16!
178	DFTRACER_UTILS_LOG_ERROR("%s", "Invalid config pointer");	×
179	return nullptr;	×
180	}
181
182	try {
183	// Convert C config to C++ config
184	StreamConfig cpp_config = StreamConfig::from_c(*config);	16!
185
186	// Create stream
187	auto stream = (*cast_reader(reader))->stream(cpp_config);	16!
188
189	// Transfer ownership to C API
190	return static_cast<dft_reader_stream_t>(stream.release());	16✔
191	} catch (const std::exception &e) {	16!
192	DFTRACER_UTILS_LOG_ERROR("Failed to create stream: %s", e.what());	×
193	return nullptr;	×
194	}	×
195	}	16✔
196
197	} // extern "C"

llnl / dftracer-utils / 23529483807

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