feat(dfr): add timing measurements.

compiler/include/concretelang/Runtime/runtime_api.h

@@ -27,8 +27,8 @@ void _dfr_deallocate_future_data(void *);
 
 /*  Initialisation & termination.  */
 void _dfr_start_c(void *);
-void _dfr_start();
-void _dfr_stop();
+void _dfr_start(int);
+void _dfr_stop(int);
 
 void _dfr_terminate();
 }

compiler/include/concretelang/Runtime/time_util.h

@@ -0,0 +1,95 @@
+// Part of the Concrete Compiler Project, under the BSD3 License with Zama
+// Exceptions. See
+// https://github.com/zama-ai/concrete-compiler-internal/blob/main/LICENSE.txt
+// for license information.
+
+#ifndef CONCRETELANG_DFR_TIME_UTIL_H
+#define CONCRETELANG_DFR_TIME_UTIL_H
+
+#if CONCRETELANG_TIMING_ENABLED
+
+#include <assert.h>
+#include <iostream>
+#include <time.h>
+
+#include "concretelang/Runtime/DFRuntime.hpp"
+
+#define TIME_UTIL_CLOCK CLOCK_MONOTONIC
+
+static inline int timespec_diff(struct timespec *, const struct timespec *,
+                                const struct timespec *);
+
+#define BEGIN_TIME(p)                                                          \
+  do {                                                                         \
+    assert(clock_gettime(TIME_UTIL_CLOCK, (p)) == 0);                          \
+  } while (0)
+
+#if CONCRETELANG_PARALLEL_EXECUTION_ENABLED
+#define END_TIME(p, m)                                                         \
+  do {                                                                         \
+    struct timespec _end_time_tv;                                              \
+    assert(clock_gettime(TIME_UTIL_CLOCK, &_end_time_tv) == 0);                \
+    assert(timespec_diff((p), &_end_time_tv, (p)) == 0);                       \
+    std::cout << "[NODE \t" << _dfr_debug_get_node_id() << "] \t" << (m)       \
+              << " time : \t" << (p)->tv_sec << "." << (p)->tv_nsec            \
+              << " seconds.\n"                                                 \
+              << std::flush;                                                   \
+  } while (0)
+#else
+#define END_TIME(p, m)                                                         \
+  do {                                                                         \
+    struct timespec _end_time_tv;                                              \
+    assert(clock_gettime(TIME_UTIL_CLOCK, &_end_time_tv) == 0);                \
+    assert(timespec_diff((p), &_end_time_tv, (p)) == 0);                       \
+    std::cout << (m) << " time : \t" << (p)->tv_sec << "." << (p)->tv_nsec     \
+              << " seconds.\n"                                                 \
+              << std::flush;                                                   \
+  } while (0)
+#endif
+
+static inline double get_thread_cpu_time(void) {
+  struct timespec _tv;
+  double _t;
+
+  assert(clock_gettime(CLOCK_THREAD_CPUTIME_ID, &_tv) == 0);
+  _t = _tv.tv_sec;
+  _t += _tv.tv_nsec * 1e-9;
+  return _t;
+}
+
+static inline int timespec_diff(struct timespec *_result,
+                                const struct timespec *_px,
+                                const struct timespec *_py) {
+  struct timespec _x, _y;
+
+  _x = *_px;
+  _y = *_py;
+
+  /* Perform the carry for the later subtraction by updating y. */
+  if (_x.tv_nsec < _y.tv_nsec) {
+    long _ns = (_y.tv_nsec - _x.tv_nsec) / 1000000000L + 1;
+    _y.tv_nsec -= 1000000000L * _ns;
+    _y.tv_sec += _ns;
+  }
+  if (_x.tv_nsec - _y.tv_nsec > 1000000000L) {
+    long _ns = (_x.tv_nsec - _y.tv_nsec) / 1000000000L;
+    _y.tv_nsec += 1000000000L * _ns;
+    _y.tv_sec -= _ns;
+  }
+
+  /* Compute the time remaining to wait. tv_nsec is certainly
+     positive. */
+  _result->tv_sec = _x.tv_sec - _y.tv_sec;
+  _result->tv_nsec = _x.tv_nsec - _y.tv_nsec;
+
+  /* Return 1 if result is negative. */
+  return _x.tv_sec < _y.tv_sec;
+}
+
+#else // CONCRETELANG_TIMING_ENABLED
+
+#define BEGIN_TIME(p)
+#define END_TIME(p, m)
+
+#endif // CONCRETELANG_TIMING_ENABLED
+#endif