29787659139

Committed 20 Jul 2026 11:34PM UTC coverage: 51.578% (-1.1%) from 52.66%

Build # 29787659139

Build Type

Pull #99

github

Committed by

web-flow

Commit Message

Merge ee805adeb into 06bc84ec9

Pull Request Pull Request #99: Support CM time_metric (NS/MS/SEC/US) across reader and viz

Coverage Stats

34832 of 86278 branches covered (40.37%)

Branch coverage included in aggregate %.

1034 of 1319 new or added lines in 30 files covered. (78.39%)

5193 existing lines in 197 files now uncovered.

35349 of 49791 relevant lines covered (70.99%)

9765.54 hits per line

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

68.48

/src/dftracer/utils/core/rocksdb/key_codec.cpp

#include <dftracer/utils/core/common/error.h>
#include <dftracer/utils/core/rocksdb/key_codec.h>

#include <stdexcept>

namespace dftracer::utils::rocksdb {

namespace {

template <typename T>
T decode_big_endian(std::string_view bytes) {
    if (bytes.size() != sizeof(T)) {
        throw DFTUtilsException(ErrorCode::PARSE,
                                "KeyCodec: invalid big-endian integer width");
    }

    T value = 0;
    for (unsigned char byte : bytes) {
        value = static_cast<T>((value << 8U) | byte);
    }
    return value;
}

}  // namespace

std::string KeyCodec::encode_be32(std::uint32_t value) {
    std::string out;
    out.reserve(sizeof(value));
    append_be32(out, value);
    return out;
}

std::string KeyCodec::encode_be64(std::uint64_t value) {
    std::string out;
    out.reserve(sizeof(value));
    append_be64(out, value);
    return out;
}

std::uint32_t KeyCodec::decode_be32(std::string_view bytes) {
    return decode_big_endian<std::uint32_t>(bytes);
}

std::uint64_t KeyCodec::decode_be64(std::string_view bytes) {
    return decode_big_endian<std::uint64_t>(bytes);
}

void KeyCodec::append_be32(std::string& out, std::uint32_t value) {
    for (int shift = 24; shift >= 0; shift -= 8) {
        out.push_back(static_cast<char>((value >> shift) & 0xFFU));
    }
}

void KeyCodec::append_be64(std::string& out, std::uint64_t value) {
    for (int shift = 56; shift >= 0; shift -= 8) {
        out.push_back(static_cast<char>((value >> shift) & 0xFFU));
    }
}

KeyBuilder& KeyBuilder::append_tag(std::string_view tag) {
    key_.append(tag);
    return *this;
}

KeyBuilder& KeyBuilder::append_separator() {
    key_.push_back('\0');
    return *this;
}

KeyBuilder& KeyBuilder::append_string(std::string_view value) {
    key_.append(value);
    return *this;
}

KeyBuilder& KeyBuilder::append_be32(std::uint32_t value) {
    KeyCodec::append_be32(key_, value);
    return *this;
}

KeyBuilder& KeyBuilder::append_be64(std::uint64_t value) {
    KeyCodec::append_be64(key_, value);
    return *this;
}

std::string KeyBuilder::build() const { return key_; }

void KeyBuilder::clear() { key_.clear(); }

}  // namespace dftracer::utils::rocksdb

1	#include <dftracer/utils/core/common/error.h>
2	#include <dftracer/utils/core/rocksdb/key_codec.h>
3
4	#include <stdexcept>
5
6	namespace dftracer::utils::rocksdb {
7
8	namespace {
9
10	template <typename T>
11	T decode_big_endian(std::string_view bytes) {	329,886✔
12	if (bytes.size() != sizeof(T)) {	329,886!
13	throw DFTUtilsException(ErrorCode::PARSE,	×
UNCOV 14	"KeyCodec: invalid big-endian integer width");	×
15	}
16
17	T value = 0;	329,886✔
18	for (unsigned char byte : bytes) {	2,783,691✔
19	value = static_cast<T>((value << 8U) \| byte);	2,453,805✔
20	}
21	return value;	329,886✔
UNCOV 22	}	×
23
24	} // namespace
25
26	std::string KeyCodec::encode_be32(std::uint32_t value) {	18,442✔
27	std::string out;	18,442✔
28	out.reserve(sizeof(value));	18,442✔
29	append_be32(out, value);	18,439✔
30	return out;	18,436✔
31	}	18,442!
32
33	std::string KeyCodec::encode_be64(std::uint64_t value) {	1,743✔
34	std::string out;	1,743✔
35	out.reserve(sizeof(value));	1,743!
36	append_be64(out, value);	1,743!
37	return out;	1,743✔
38	}	1,743!
39
40	std::uint32_t KeyCodec::decode_be32(std::string_view bytes) {	46,250✔
41	return decode_big_endian<std::uint32_t>(bytes);	46,250✔
42	}
43
44	std::uint64_t KeyCodec::decode_be64(std::string_view bytes) {	283,655✔
45	return decode_big_endian<std::uint64_t>(bytes);	283,655✔
46	}
47
48	void KeyCodec::append_be32(std::string& out, std::uint32_t value) {	81,279✔
49	for (int shift = 24; shift >= 0; shift -= 8) {	406,366✔
50	out.push_back(static_cast<char>((value >> shift) & 0xFFU));	325,087✔
51	}	325,087✔
52	}	81,279✔
53
54	void KeyCodec::append_be64(std::string& out, std::uint64_t value) {	83,635✔
55	for (int shift = 56; shift >= 0; shift -= 8) {	752,335✔
56	out.push_back(static_cast<char>((value >> shift) & 0xFFU));	668,700✔
57	}	668,700✔
58	}	83,635✔
59
60	KeyBuilder& KeyBuilder::append_tag(std::string_view tag) {	1✔
61	key_.append(tag);	1✔
62	return *this;	1✔
63	}
64
65	KeyBuilder& KeyBuilder::append_separator() {	1✔
66	key_.push_back('\0');	1✔
67	return *this;	1✔
68	}
69
70	KeyBuilder& KeyBuilder::append_string(std::string_view value) {	×
71	key_.append(value);	×
72	return *this;	×
73	}
74
75	KeyBuilder& KeyBuilder::append_be32(std::uint32_t value) {	1✔
76	KeyCodec::append_be32(key_, value);	1✔
77	return *this;	1✔
78	}
79
80	KeyBuilder& KeyBuilder::append_be64(std::uint64_t value) {	1✔
81	KeyCodec::append_be64(key_, value);	1✔
82	return *this;	1✔
83	}
84
85	std::string KeyBuilder::build() const { return key_; }	1✔
86
87	void KeyBuilder::clear() { key_.clear(); }	×
88
89	} // namespace dftracer::utils::rocksdb

llnl / dftracer-utils / 29787659139

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