diff --git a/ddtrace/internal/datadog/profiling/dd_wrapper/src/uploader.cpp b/ddtrace/internal/datadog/profiling/dd_wrapper/src/uploader.cpp index b51ba0daf31..3b96a3fc554 100644 --- a/ddtrace/internal/datadog/profiling/dd_wrapper/src/uploader.cpp +++ b/ddtrace/internal/datadog/profiling/dd_wrapper/src/uploader.cpp @@ -54,7 +54,7 @@ Datadog::Uploader::export_to_file(ddog_prof_EncodedProfile& encoded, std::string ddog_Error_drop(&bytes_res.err); return false; } - out.write(reinterpret_cast(bytes_res.ok.ptr), bytes_res.ok.len); + out.write(reinterpret_cast(bytes_res.ok.ptr), static_cast(bytes_res.ok.len)); if (out.fail()) { std::cerr << "Error writing to output file " << pprof_filename << ": " << strerror(errno) << std::endl; return false; diff --git a/ddtrace/internal/datadog/profiling/stack/echion/echion/greenlets.h b/ddtrace/internal/datadog/profiling/stack/echion/echion/greenlets.h index 9204bfdc430..b415ab77e45 100644 --- a/ddtrace/internal/datadog/profiling/stack/echion/echion/greenlets.h +++ b/ddtrace/internal/datadog/profiling/stack/echion/echion/greenlets.h @@ -36,5 +36,5 @@ class GreenletInfo { } - int unwind(EchionSampler& echion, PyObject*, PyThreadState*, FrameStack&); + void unwind(EchionSampler& echion, PyObject*, PyThreadState*, FrameStack&); }; diff --git a/ddtrace/internal/datadog/profiling/stack/echion/echion/timing.h b/ddtrace/internal/datadog/profiling/stack/echion/echion/timing.h index e878a257ece..a05ef498eeb 100644 --- a/ddtrace/internal/datadog/profiling/stack/echion/echion/timing.h +++ b/ddtrace/internal/datadog/profiling/stack/echion/echion/timing.h @@ -4,7 +4,9 @@ #pragma once -typedef unsigned long microsecond_t; +#include + +typedef int64_t microsecond_t; #define TS_TO_MICROSECOND(ts) ((ts).tv_sec * 1e6 + (ts).tv_nsec / 1e3) #define TV_TO_MICROSECOND(tv) ((tv).seconds * 1e6 + (tv).microseconds) diff --git a/ddtrace/internal/datadog/profiling/stack/include/stack_renderer.hpp b/ddtrace/internal/datadog/profiling/stack/include/stack_renderer.hpp index 5a247e28de3..dde17a69c6e 100644 --- a/ddtrace/internal/datadog/profiling/stack/include/stack_renderer.hpp +++ b/ddtrace/internal/datadog/profiling/stack/include/stack_renderer.hpp @@ -86,7 +86,7 @@ class StackRenderer void render_task_begin(const std::string& task_name, bool on_cpu); void render_stack_begin(); void render_frame(Frame& frame); - void render_cpu_time(uint64_t cpu_time_us); + void render_cpu_time(microsecond_t cpu_time_us); void render_stack_end(); // Clear caches after fork to avoid using stale interned string/function IDs diff --git a/ddtrace/internal/datadog/profiling/stack/src/echion/danger.cc b/ddtrace/internal/datadog/profiling/stack/src/echion/danger.cc index b3ae5440d02..43d047d9373 100644 --- a/ddtrace/internal/datadog/profiling/stack/src/echion/danger.cc +++ b/ddtrace/internal/datadog/profiling/stack/src/echion/danger.cc @@ -141,10 +141,11 @@ safe_memcpy(void* dst, const void* src, size_t n) // Copy in page-bounded chunks (at most one fault per bad page). while (rem) { - safe_memcpy_return_t to_src_pg = - page_size - (static_cast(reinterpret_cast(s)) & (page_size - 1)); - safe_memcpy_return_t to_dst_pg = - page_size - (static_cast(reinterpret_cast(d)) & (page_size - 1)); + // Values are always <= page_size, so the unsigned-to-signed narrowing is safe. + safe_memcpy_return_t to_src_pg = static_cast( + page_size - (static_cast(reinterpret_cast(s)) & (page_size - 1))); + safe_memcpy_return_t to_dst_pg = static_cast( + page_size - (static_cast(reinterpret_cast(d)) & (page_size - 1))); safe_memcpy_return_t chunk = std::min(rem, std::min(to_src_pg, to_dst_pg)); // Optional early probe to fault before entering large memcpy diff --git a/ddtrace/internal/datadog/profiling/stack/src/echion/frame.cc b/ddtrace/internal/datadog/profiling/stack/src/echion/frame.cc index e4bd879adb6..089eca99eaa 100644 --- a/ddtrace/internal/datadog/profiling/stack/src/echion/frame.cc +++ b/ddtrace/internal/datadog/profiling/stack/src/echion/frame.cc @@ -269,7 +269,7 @@ Frame::read(EchionSampler& echion, PyObject* frame_addr, PyObject** prev_addr) (static_cast( (frame_addr->instr_ptr - 1 - reinterpret_cast<_Py_CODEUNIT*>((reinterpret_cast(frame_addr->f_executable)))))) - - offsetof(PyCodeObject, co_code_adaptive) / sizeof(_Py_CODEUNIT); + static_cast(offsetof(PyCodeObject, co_code_adaptive) / sizeof(_Py_CODEUNIT)); auto maybe_frame = Frame::get(echion, reinterpret_cast(frame_addr->f_executable), lasti); if (!maybe_frame) { return ErrorKind::FrameError; diff --git a/ddtrace/internal/datadog/profiling/stack/src/echion/greenlets.cc b/ddtrace/internal/datadog/profiling/stack/src/echion/greenlets.cc index e3cf17d3982..bd16c2a0663 100644 --- a/ddtrace/internal/datadog/profiling/stack/src/echion/greenlets.cc +++ b/ddtrace/internal/datadog/profiling/stack/src/echion/greenlets.cc @@ -2,7 +2,7 @@ #include -int +void GreenletInfo::unwind(EchionSampler& echion, PyObject* cur_frame, PyThreadState* tstate, FrameStack& stack) { PyObject* frame_addr = NULL; @@ -26,10 +26,7 @@ GreenletInfo::unwind(EchionSampler& echion, PyObject* cur_frame, PyThreadState* #else // Python < 3.11 frame_addr = cur_frame == Py_None ? reinterpret_cast(tstate->frame) : cur_frame; #endif - auto count = unwind_frame(echion, frame_addr, stack); + unwind_frame(echion, frame_addr, stack); stack.push_back(Frame::get(echion, name)); - - return count + 1; // We add an extra count for the frame with the greenlet - // name. -} \ No newline at end of file +} diff --git a/ddtrace/internal/datadog/profiling/stack/src/echion/mirrors.cc b/ddtrace/internal/datadog/profiling/stack/src/echion/mirrors.cc index b408c4a7e9a..c57a918e903 100644 --- a/ddtrace/internal/datadog/profiling/stack/src/echion/mirrors.cc +++ b/ddtrace/internal/datadog/profiling/stack/src/echion/mirrors.cc @@ -10,7 +10,7 @@ MirrorSet::create(PyObject* set_addr) } auto size = set.mask + 1; - ssize_t table_size = size * sizeof(setentry); + auto table_size = size * static_cast(sizeof(setentry)); if (table_size < 0 || table_size > MAX_MIRROR_SIZE) { return ErrorKind::MirrorError; } diff --git a/ddtrace/internal/datadog/profiling/stack/src/echion/vm.cc b/ddtrace/internal/datadog/profiling/stack/src/echion/vm.cc index f612064ba0c..543e4f19786 100644 --- a/ddtrace/internal/datadog/profiling/stack/src/echion/vm.cc +++ b/ddtrace/internal/datadog/profiling/stack/src/echion/vm.cc @@ -55,7 +55,7 @@ VmReader::create(size_t sz) unlink(tmpfile.data()); // Make sure we have enough size - if (ftruncate(fd, sz) == -1) { + if (ftruncate(fd, static_cast(sz)) == -1) { continue; } @@ -109,7 +109,7 @@ VmReader::safe_copy(pid_t process_id, // Check to see if we need to resize the buffer if (remote_iov[0].iov_len > sz) { - if (ftruncate(fd, remote_iov[0].iov_len) == -1) { + if (ftruncate(fd, static_cast(remote_iov[0].iov_len)) == -1) { return 0; } else { void* tmp = mremap(buffer, sz, remote_iov[0].iov_len, MREMAP_MAYMOVE); @@ -121,7 +121,7 @@ VmReader::safe_copy(pid_t process_id, } } - ssize_t ret = pwritev(fd, remote_iov, riovcnt, 0); + ssize_t ret = pwritev(fd, remote_iov, static_cast(riovcnt), 0); if (ret == -1) { return ret; } @@ -211,7 +211,7 @@ copy_memory(proc_ref_t proc_ref, const void* addr, ssize_t len, void* buf) // Early exit on zero page if (reinterpret_cast(addr) < 4096) { - return result; + return static_cast(result); } #if defined PL_LINUX diff --git a/ddtrace/internal/datadog/profiling/stack/src/sampler.cpp b/ddtrace/internal/datadog/profiling/stack/src/sampler.cpp index 5704ff48f43..1f56f86c1f8 100644 --- a/ddtrace/internal/datadog/profiling/stack/src/sampler.cpp +++ b/ddtrace/internal/datadog/profiling/stack/src/sampler.cpp @@ -114,7 +114,8 @@ Sampler::adapt_sampling_interval() info.system_time.seconds * 1e6 + info.system_time.microseconds); #endif auto sampler_thread_delta = static_cast(new_sampler_thread_count - sampler_thread_count); - auto process_delta = static_cast(new_process_count - process_count - sampler_thread_delta); + auto process_delta = + static_cast(new_process_count) - static_cast(process_count) - sampler_thread_delta; if (process_delta <= 0) { process_delta = 1; // Avoid division by zero or negative values } diff --git a/ddtrace/internal/datadog/profiling/stack/src/stack_renderer.cpp b/ddtrace/internal/datadog/profiling/stack/src/stack_renderer.cpp index 33701ce4f21..73dbcdf57f6 100644 --- a/ddtrace/internal/datadog/profiling/stack/src/stack_renderer.cpp +++ b/ddtrace/internal/datadog/profiling/stack/src/stack_renderer.cpp @@ -15,7 +15,7 @@ using namespace Datadog; void StackRenderer::render_thread_begin(PyThreadState* tstate, std::string_view name, - microsecond_t wall_time_us, + int64_t wall_time_us, uintptr_t thread_id, unsigned long native_id) { @@ -47,7 +47,7 @@ StackRenderer::render_thread_begin(PyThreadState* tstate, thread_state.native_id = native_id; thread_state.name = std::string(name); thread_state.now_time_ns = now_ns; - thread_state.wall_time_ns = 1000LL * wall_time_us; + thread_state.wall_time_ns = 1000 * wall_time_us; thread_state.cpu_time_ns = 0; // Walltime samples are guaranteed, but CPU times are not. Initialize to 0 // since we don't know if we'll get a CPU time here. @@ -215,7 +215,7 @@ StackRenderer::render_frame(Frame& frame) } void -StackRenderer::render_cpu_time(uint64_t cpu_time_us) +StackRenderer::render_cpu_time(microsecond_t cpu_time_us) { if (sample == nullptr) { std::cerr << "Received a CPU time without sample storage. Some profiling data has been lost." << std::endl; @@ -224,7 +224,7 @@ StackRenderer::render_cpu_time(uint64_t cpu_time_us) // TODO - it's absolutely false that thread-level CPU time is task time. This needs to be normalized // to the task level, but for now just keep it because this is how the v1 sampler works - thread_state.cpu_time_ns = 1000LL * cpu_time_us; + thread_state.cpu_time_ns = 1000 * cpu_time_us; sample->push_cputime(thread_state.cpu_time_ns, 1); }