30069185152

Committed 24 Jul 2026 05:20AM UTC coverage: 50.687% (-2.0%) from 52.66%

Build # 30069185152

Build Type

Pull #99

github

Committed by

web-flow

Commit Message

Merge 47af36077 into 06bc84ec9

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

Coverage Stats

18062 of 48203 branches covered (37.47%)

Branch coverage included in aggregate %.

1510 of 2205 new or added lines in 59 files covered. (68.48%)

742 existing lines in 114 files now uncovered.

23711 of 34210 relevant lines covered (69.31%)

39853.91 hits per line

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

87.76

/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) {	20✔
13	char b;
14	ssize_t n = ::recv(fd, &b, 1, MSG_PEEK \| MSG_DONTWAIT);	20!
15	if (n == 0) return true; // orderly shutdown (FIN)	20✔
16	if (n < 0) {	19!
17	int e = errno;	19✔
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;	19✔
23	#endif
24	}
NEW 25	return false; // data buffered (e.g. a pipelined request): still connected	×
26	}
27
28	} // namespace
29
30	bool CancelToken::cancelled() const {	189✔
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;	189✔
34	if (!state_) return false;	187✔
35	if (state_->flag.load(std::memory_order_relaxed)) return true;	146✔
36	if (state_->peer_fd < 0) return false;	141✔
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)	280✔
39	return false;	120✔
40	if (peer_disconnected(state_->peer_fd)) {	20✔
41	state_->flag.store(true, std::memory_order_relaxed);	1✔
42	return true;	1✔
43	}
44	return false;	19✔
45	}
46
47	CancelRegistry& CancelRegistry::instance() {	129✔
48	static CancelRegistry registry;	129!
49	return registry;	129✔
50	}
51
52	CancelToken CancelRegistry::create(const std::string& id, int peer_fd) {	72✔
53	auto state = std::make_shared<CancelState>();	72!
54	state->peer_fd = peer_fd;	72✔
55	if (!id.empty()) {	72✔
56	std::lock_guard<std::mutex> lock(mu_);	8!
57	tokens_[id] = state;	8!
58	}	8✔
59	return CancelToken(state);	144✔
60	}	72✔
61
62	void CancelRegistry::remove(const std::string& id) {	65✔
63	if (id.empty()) return;	65✔
64	std::lock_guard<std::mutex> lock(mu_);	2!
65	tokens_.erase(id);	2!
66	}	2✔
67
68	bool CancelRegistry::cancel(const std::string& id) {	7✔
69	if (id.empty()) return false;	7✔
70	std::shared_ptr<CancelState> state;	6✔
71	{
72	std::lock_guard<std::mutex> lock(mu_);	6!
73	auto it = tokens_.find(id);	6!
74	if (it == tokens_.end()) return false;	6✔
75	state = it->second;	3✔
76	}	6✔
77	state->flag.store(true, std::memory_order_relaxed);	3✔
78	return true;	3✔
79	}	6✔
80
81	std::size_t CancelRegistry::size() const {	3✔
82	std::lock_guard<std::mutex> lock(mu_);	3!
83	return tokens_.size();	6✔
84	}	3✔
85
86	} // namespace dftracer::utils::server

llnl / dftracer-utils / 30069185152

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