thread cpu time

Author: pzuev

ydb/core/kqp/tools/combiner_perf/printout.cpp

@@ -2,6 +2,10 @@
 
 #include <sys/resource.h>
 
+#if defined (_darwin_)
+#include <mach/mach.h>
+#endif
+
 long GetMaxRSS()
 {
     rusage usage;
@@ -16,7 +20,7 @@ long GetMaxRSSDelta(const long prevMaxRss)
     long maxRss = GetMaxRSS();
 
     if (maxRss <= 0 || prevMaxRss <= 0 || maxRss < prevMaxRss) {
-        ythrow yexception() << "Bad maxRSS measurement, before: " << prevMaxRss << ", after: " << maxRss << Endl;        
+        ythrow yexception() << "Bad maxRSS measurement, before: " << prevMaxRss << ", after: " << maxRss << Endl;
     }
 
 #if defined (_darwin_)
@@ -28,6 +32,39 @@ long GetMaxRSSDelta(const long prevMaxRss)
     return (maxRss - prevMaxRss) * factor;
 }
 
+TDuration GetThreadCPUTime()
+{
+    ui64 us = 0;
+
+#if defined (_darwin_)
+    thread_basic_info_data_t info = {};
+    mach_msg_type_number_t info_count = THREAD_BASIC_INFO_COUNT;
+    kern_return_t kern_err = thread_info(
+        mach_thread_self(),
+        THREAD_BASIC_INFO,
+        (thread_info_t)&info,
+        &info_count
+    );
+    if (kern_err == KERN_SUCCESS) {
+        us = 1000000ULL * info.user_time.seconds + info.user_time.microseconds + 1000000ULL*info.system_time.seconds + info.system_time.microseconds;
+    }
+#else
+    us = ThreadCPUTime();
+#endif
+
+    if (!us) {
+        ythrow yexception() << "Failed to obtain thread CPU time";
+    }
+
+    return TDuration::MicroSeconds(us);
+}
+
+TDuration GetThreadCPUTimeDelta(const TDuration startTime)
+{
+    TDuration current = GetThreadCPUTime();
+    return current - startTime;
+}
+
 void MergeRunResults(const TRunResult& src, TRunResult& dst)
 {
     dst.ResultTime = Min(src.ResultTime, dst.ResultTime);

ydb/core/kqp/tools/combiner_perf/printout.h

@@ -40,6 +40,10 @@ class TTestResultCollector {
 };
 
 // ru_maxrss from rusage, converted to bytes
-long GetMaxRSS();
+long Y_NO_INLINE GetMaxRSS();
 
-long GetMaxRSSDelta(const long prevMaxRss);
+long Y_NO_INLINE GetMaxRSSDelta(const long prevMaxRss);
+
+TDuration Y_NO_INLINE GetThreadCPUTime();
+
+TDuration Y_NO_INLINE GetThreadCPUTimeDelta(const TDuration startTime);

ydb/core/kqp/tools/combiner_perf/simple.cpp

@@ -63,22 +63,22 @@ TRunResult RunTestOverGraph(const TRunParams& params, const bool needsVerificati
         // Compute node implementation
 
         Cerr << "Compute graph result" << Endl;
-        const auto graphTimeStart = TInstant::Now();
+        const auto graphTimeStart = GetThreadCPUTime();
         size_t lineCount = CountWideStreamOutputs<2>(computeGraphPtr->GetValue());
         Cerr << lineCount << Endl;
 
-        return TInstant::Now() - graphTimeStart;
+        return GetThreadCPUTimeDelta(graphTimeStart);
     };
 
     auto measureRefTime = [&](auto& computeGraphPtr, IDataSampler& sampler) {
         // Reference implementation (sum via an std::unordered_map)
 
         Cerr << "Compute reference result" << Endl;
         auto referenceStream = sampler.MakeStream(computeGraphPtr->GetHolderFactory());
-        const auto cppTimeStart = TInstant::Now();
+        const auto cppTimeStart = GetThreadCPUTime();
         sampler.ComputeReferenceResult(*referenceStream);
 
-        return TInstant::Now() - cppTimeStart;
+        return GetThreadCPUTimeDelta(cppTimeStart);
     };
 
     auto graphRun1 = BuildGraph(setup, *sampler, params.WideCombinerMemLimit);
@@ -106,13 +106,13 @@ TRunResult RunTestOverGraph(const TRunParams& params, const bool needsVerificati
         // Measure the input stream run time
         Cerr << "Generator run" << Endl;
         const auto devnullStream = sampler->MakeStream(graphRun1->GetHolderFactory());
-        const auto devnullStart = TInstant::Now();
+        const auto devnullStart = GetThreadCPUTime();
         {
             NUdf::TUnboxedValue columns[2];
             while (devnullStream->WideFetch(columns, 2) == NUdf::EFetchStatus::Ok) {
             }
         }
-        result.GeneratorTime = TInstant::Now() - devnullStart;
+        result.GeneratorTime = GetThreadCPUTimeDelta(devnullStart);
 
         if (params.TestMode == ETestMode::GeneratorOnly) {
             return result;

ydb/core/kqp/tools/combiner_perf/simple_block.cpp

@@ -70,33 +70,33 @@ TRunResult RunTestOverGraph(const TRunParams& params, const bool measureReferenc
         // Compute graph implementation
         auto stream = NUdf::TUnboxedValuePod(sampler->MakeStream(computeGraphPtr->GetContext()).Release());
         computeGraphPtr->GetEntryPoint(0, true)->SetValue(computeGraphPtr->GetContext(), std::move(stream));
-        const auto graphStart = TInstant::Now();
+        const auto graphStart = GetThreadCPUTime();
         resultList = computeGraphPtr->GetValue();
-        return TInstant::Now() - graphStart;
+        return GetThreadCPUTimeDelta(graphStart);
     };
 
     auto measureRefTime = [&](auto& computeGraphPtr) {
         // Reference implementation (sum via an std::unordered_map)
-        const auto cppStart = TInstant::Now();
+        const auto cppStart = GetThreadCPUTime();
         sampler->ComputeReferenceResult(computeGraphPtr->GetContext());
-        return TInstant::Now() - cppStart;
+        return GetThreadCPUTimeDelta(cppStart);
     };
 
     auto measureGeneratorTime = [&](auto& computeGraphPtr) {
         // Generator-only loop
         const auto devnullStreamPtr = sampler->MakeStream(computeGraphPtr->GetContext());
         auto& devnullStream = *devnullStreamPtr;
         size_t numBlocks = 0;
-        const auto timeStart = TInstant::Now();
+        const auto timeStart = GetThreadCPUTime();
         {
             NUdf::TUnboxedValue columns[3];
             while (devnullStream.WideFetch(columns, 3) == NUdf::EFetchStatus::Ok) {
                 ++numBlocks;
             }
         }
-        auto timeEnd = TInstant::Now();
+        auto duration = GetThreadCPUTimeDelta(timeStart);
         Cerr << "Blocks generated: " << numBlocks << Endl;
-        return timeEnd - timeStart;
+        return duration;
     };
 
     const auto graph = setup.BuildGraph(pgmReturn, {streamCallable});

ydb/core/kqp/tools/combiner_perf/simple_last.cpp

@@ -90,22 +90,22 @@ TRunResult RunTestOverGraph(const TRunParams& params, const bool needsVerificati
         // Compute node implementation
 
         Cerr << "Compute graph result" << Endl;
-        const auto graphTimeStart = TInstant::Now();
+        const auto graphTimeStart = GetThreadCPUTime();
         size_t lineCount = CountWideStreamOutputs<2>(computeGraphPtr->GetValue());
         Cerr << lineCount << Endl;
 
-        return TInstant::Now() - graphTimeStart;
+        return GetThreadCPUTimeDelta(graphTimeStart);
     };
 
     auto measureRefTime = [&](auto& computeGraphPtr, IDataSampler& sampler) {
         // Reference implementation (sum via an std::unordered_map)
 
         Cerr << "Compute reference result" << Endl;
         auto referenceStream = sampler.MakeStream(computeGraphPtr->GetHolderFactory());
-        const auto cppTimeStart = TInstant::Now();
+        const auto cppTimeStart = GetThreadCPUTime();
         sampler.ComputeReferenceResult(*referenceStream);
 
-        return TInstant::Now() - cppTimeStart;
+        return GetThreadCPUTimeDelta(cppTimeStart);
     };
 
     auto graphRun1 = BuildGraph(setup, spillerFactory, *sampler);