30074477855

Committed 24 Jul 2026 07:08AM UTC coverage: 52.727% (+0.07%) from 52.66%

Build # 30074477855

Build Type

Pull #99

github

Committed by

web-flow

Commit Message

Merge bfddb8de9 into 06bc84ec9

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

Coverage Stats

42091 of 103330 branches covered (40.73%)

Branch coverage included in aggregate %.

2472 of 3143 new or added lines in 65 files covered. (78.65%)

146 existing lines in 14 files now uncovered.

37235 of 47117 relevant lines covered (79.03%)

68905.24 hits per line

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

88.68

/src/dftracer/utils/server/cancel.cpp

#include <dftracer/utils/server/cancel.h>
#include <dftracer/utils/server/signal_handler.h>
#include <sys/socket.h>

#include <cerrno>

namespace dftracer::utils::server {

namespace {

// Non-blocking peek: true if the peer has closed or reset the connection.
bool peer_disconnected(int fd) {
    char b;
    ssize_t n = ::recv(fd, &b, 1, MSG_PEEK | MSG_DONTWAIT);
    if (n == 0) return true;  // orderly shutdown (FIN)
    if (n < 0) {
        int e = errno;
        // "No data yet" vs. a real reset/error.
#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
        return e != EAGAIN && e != EWOULDBLOCK;
#else
        return e != EAGAIN;
#endif
    }
    return false;  // data buffered (e.g. a pipelined request): still connected
}

}  // namespace

bool CancelToken::cancelled() const {
    // Shutdown cancels everything, including work started without a token, so
    // Ctrl-C does not wait out a long scan.
    if (g_shutdown_requested.load(std::memory_order_acquire)) return true;
    if (!state_) return false;
    if (state_->flag.load(std::memory_order_relaxed)) return true;
    if (state_->peer_fd < 0) return false;
    // Probe the socket only every 16th check to keep the hot path cheap.
    if ((state_->probe_tick.fetch_add(1, std::memory_order_relaxed) & 0xF) != 0)
        return false;
    if (peer_disconnected(state_->peer_fd)) {
        state_->flag.store(true, std::memory_order_relaxed);
        return true;
    }
    return false;
}

CancelRegistry& CancelRegistry::instance() {
    static CancelRegistry registry;
    return registry;
}

CancelToken CancelRegistry::create(const std::string& id, int peer_fd) {
    auto state = std::make_shared<CancelState>();
    state->peer_fd = peer_fd;
    if (!id.empty()) {
        std::lock_guard<std::mutex> lock(mu_);
        tokens_[id] = state;
    }
    return CancelToken(state);
}

void CancelRegistry::remove(const std::string& id) {
    if (id.empty()) return;
    std::lock_guard<std::mutex> lock(mu_);
    tokens_.erase(id);
}

bool CancelRegistry::cancel(const std::string& id) {
    if (id.empty()) return false;
    std::shared_ptr<CancelState> state;
    {
        std::lock_guard<std::mutex> lock(mu_);
        auto it = tokens_.find(id);
        if (it == tokens_.end()) return false;
        state = it->second;
    }
    state->flag.store(true, std::memory_order_relaxed);
    return true;
}

std::size_t CancelRegistry::size() const {
    std::lock_guard<std::mutex> lock(mu_);
    return tokens_.size();
}

}  // namespace dftracer::utils::server

1	#include <dftracer/utils/server/cancel.h>
2	#include <dftracer/utils/server/signal_handler.h>
3	#include <sys/socket.h>
4
5	#include <cerrno>
6
7	namespace dftracer::utils::server {
8
9	namespace {
10
11	// Non-blocking peek: true if the peer has closed or reset the connection.
12	bool peer_disconnected(int fd) {	40✔
13	char b;
14	ssize_t n = ::recv(fd, &b, 1, MSG_PEEK \| MSG_DONTWAIT);	40!
15	if (n == 0) return true; // orderly shutdown (FIN)	40✔
16	if (n < 0) {	38✔
17	int e = errno;	38✔
18	// "No data yet" vs. a real reset/error.
19	#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
20	return e != EAGAIN && e != EWOULDBLOCK;
21	#else
22	return e != EAGAIN;	38✔
23	#endif
24	}
NEW 25	return false; // data buffered (e.g. a pipelined request): still connected	×
26	}	20✔
27
28	} // namespace
29
30	bool CancelToken::cancelled() const {	381✔
31	// Shutdown cancels everything, including work started without a token, so
32	// Ctrl-C does not wait out a long scan.
33	if (g_shutdown_requested.load(std::memory_order_acquire)) return true;	381✔
34	if (!state_) return false;	379✔
35	if (state_->flag.load(std::memory_order_relaxed)) return true;	292✔
36	if (state_->peer_fd < 0) return false;	282✔
37	// Probe the socket only every 16th check to keep the hot path cheap.
38	if ((state_->probe_tick.fetch_add(1, std::memory_order_relaxed) & 0xF) != 0)	420✔
39	return false;	240✔
40	if (peer_disconnected(state_->peer_fd)) {	40✔
41	state_->flag.store(true, std::memory_order_relaxed);	2✔
42	return true;	2✔
43	}
44	return false;	38✔
45	}	192✔
46
47	CancelRegistry& CancelRegistry::instance() {	258✔
48	static CancelRegistry registry;	258✔
49	return registry;	258✔
50	}
51
52	CancelToken CancelRegistry::create(const std::string& id, int peer_fd) {	144✔
53	auto state = std::make_shared<CancelState>();	144!
54	state->peer_fd = peer_fd;	144✔
55	if (!id.empty()) {	144✔
56	std::lock_guard<std::mutex> lock(mu_);	16!
57	tokens_[id] = state;	16!
58	}	16✔
59	return CancelToken(state);	216!
60	}	144✔
61
62	void CancelRegistry::remove(const std::string& id) {	130✔
63	if (id.empty()) return;	130✔
64	std::lock_guard<std::mutex> lock(mu_);	4!
65	tokens_.erase(id);	4!
66	}	67✔
67
68	bool CancelRegistry::cancel(const std::string& id) {	14✔
69	if (id.empty()) return false;	14✔
70	std::shared_ptr<CancelState> state;	12✔
71	{
72	std::lock_guard<std::mutex> lock(mu_);	12!
73	auto it = tokens_.find(id);	12!
74	if (it == tokens_.end()) return false;	12✔
75	state = it->second;	6!
76	}	12✔
77	state->flag.store(true, std::memory_order_relaxed);	6✔
78	return true;	6✔
79	}	13✔
80
81	std::size_t CancelRegistry::size() const {	6✔
82	std::lock_guard<std::mutex> lock(mu_);	6!
83	return tokens_.size();	9✔
84	}	6✔
85
86	} // namespace dftracer::utils::server

llnl / dftracer-utils / 30074477855

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