✨ QDMI Environment Implementation

.github/workflows/ci.yml

@@ -29,8 +29,6 @@ jobs:
     with:
       # do not try to build docs in test builds
       cmake-args: "-DBUILD_QDMI_DOCS=OFF -G Ninja"
-    secrets:
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
   linter:
     name: 🇨‌ Lint

.github/workflows/reusable-cpp-ci.yml

@@ -14,9 +14,6 @@ on:
         description: "Additional arguments to pass to CMake on macOS"
         default: ""
         type: string
-    secrets:
-      CODECOV_TOKEN:
-        required: true
 
 jobs:
   cpp-tests-ubuntu:
@@ -45,6 +42,9 @@ jobs:
   coverage:
     name: 📈
     runs-on: ubuntu-latest
+    permissions:
+      contents: read # Required for the `actions/checkout` action
+      id-token: write # Required for the `codecov/codecov-action` action
     env:
       CMAKE_BUILD_PARALLEL_LEVEL: 4
       CTEST_PARALLEL_LEVEL: 4
@@ -65,4 +65,4 @@ jobs:
         with:
           fail_ci_if_error: true
           flags: cpp
-          token: ${{ secrets.CODECOV_TOKEN }}
+          use_oidc: true

cmake/prefix_defs.txt

@@ -24,3 +24,16 @@ QDMI_Site
 QDMI_Site_impl_d
 QDMI_Operation
 QDMI_Operation_impl_d
+QDMI_TelemetrySensor
+QDMI_TelemetrySensor_impl_d
+QDMI_Device_TelemetrySensor_Query
+QDMI_Device_TelemetrySensor_Query_impl_d
+QDMI_device_session_query_telemetrysensor_property
+QDMI_device_session_create_device_telemetrysensor_query
+QDMI_device_telemetrysensor_query_set_parameter
+QDMI_device_telemetrysensor_query_submit
+QDMI_device_telemetrysensor_query_get_results
+QDMI_device_telemetrysensor_query_check_status
+QDMI_device_telemetrysensor_query_wait
+QDMI_device_telemetrysensor_query_cancel
+QDMI_device_telemetrysensor_query_free

examples/device/device.cpp

@@ -26,10 +26,14 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include <algorithm>
 #include <array>
+#include <chrono>
 #include <cmath>
 #include <complex>
+#include <cstddef>
 #include <cstdint>
+#include <cstdlib>
 #include <cstring>
+#include <ctime>
 #include <functional>
 #include <iterator>
 #include <limits>
@@ -77,6 +81,24 @@ struct CXX_QDMI_Operation_impl_d {
   std::string name;
 };
 
+struct CXX_QDMI_TelemetrySensor_impl_d {
+  std::string id;
+  std::string unit;
+  uint64_t sampling_rate;
+};
+
+struct CXX_QDMI_Device_TelemetrySensor_Query_impl_d {
+  std::chrono::time_point<std::chrono::system_clock> start_time;
+  std::chrono::time_point<std::chrono::system_clock> end_time;
+  std::chrono::seconds timeout = std::chrono::seconds();
+  CXX_QDMI_TelemetrySensor telemetry_sensor = nullptr;
+  std::vector<std::chrono::time_point<std::chrono::system_clock>>
+      result_timestamps;
+  std::vector<double> result_values;
+  QDMI_TelemetrySensor_Query_Status status =
+      QDMI_TELEMETRYSENSOR_QUERY_STATUS_CREATED;
+};
+
 namespace {
 /**
  * @brief Static function to maintain the device state.
@@ -159,6 +181,11 @@ constexpr CXX_QDMI_Site_impl_d SITE4{4};
 constexpr std::array<const CXX_QDMI_Site_impl_d *, 5> CXX_DEVICE_SITES = {
     &SITE0, &SITE1, &SITE2, &SITE3, &SITE4};
 
+const CXX_QDMI_TelemetrySensor_impl_d ENVSEN{"t4k", "K", 60};
+
+constexpr std::array<const CXX_QDMI_TelemetrySensor_impl_d *, 1>
+    CXX_DEVICE_TELEMETRYSENSORS{&ENVSEN};
+
 constexpr std::array<const CXX_QDMI_Site_impl_d *, 20>
     // clang-format off
     DEVICE_COUPLING_MAP = {
@@ -773,6 +800,9 @@ int CXX_QDMI_device_session_query_device_property(
   ADD_SINGLE_VALUE_PROPERTY(QDMI_DEVICE_PROPERTY_NEEDSCALIBRATION, size_t, 0,
                             prop, size, value, size_ret)
 
+  ADD_LIST_PROPERTY(QDMI_DEVICE_PROPERTY_TELEMETRYSENSORS,
+                    CXX_QDMI_TelemetrySensor, CXX_DEVICE_TELEMETRYSENSORS, prop,
+                    size, value, size_ret)
   ADD_SINGLE_VALUE_PROPERTY(
       QDMI_DEVICE_PROPERTY_PULSESUPPORT, QDMI_Device_Pulse_Support_Level,
       QDMI_DEVICE_PULSE_SUPPORT_LEVEL_NONE, prop, size, value, size_ret)
@@ -889,3 +919,226 @@ int CXX_QDMI_device_session_query_operation_property(
   }
   return QDMI_ERROR_NOTSUPPORTED;
 } /// [DOXYGEN FUNCTION END]
+
+int CXX_QDMI_device_session_query_telemetrysensor_property(
+    CXX_QDMI_Device_Session session, CXX_QDMI_TelemetrySensor telemetry_sensor,
+    QDMI_TelemetrySensor_Property prop, size_t size, void *value,
+    size_t *size_ret) {
+  if (session == nullptr || telemetry_sensor == nullptr ||
+      (value != nullptr && size == 0) ||
+      (prop >= QDMI_TELEMETRYSENSOR_PROPERTY_MAX &&
+       prop != QDMI_TELEMETRYSENSOR_PROPERTY_CUSTOM1 &&
+       prop != QDMI_TELEMETRYSENSOR_PROPERTY_CUSTOM2 &&
+       prop != QDMI_TELEMETRYSENSOR_PROPERTY_CUSTOM3 &&
+       prop != QDMI_TELEMETRYSENSOR_PROPERTY_CUSTOM4 &&
+       prop != QDMI_TELEMETRYSENSOR_PROPERTY_CUSTOM5)) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+  ADD_STRING_PROPERTY(QDMI_TELEMETRYSENSOR_PROPERTY_ID,
+                      telemetry_sensor->id.c_str(), prop, size, value, size_ret)
+  ADD_STRING_PROPERTY(QDMI_TELEMETRYSENSOR_PROPERTY_UNIT,
+                      telemetry_sensor->unit.c_str(), prop, size, value,
+                      size_ret)
+  ADD_SINGLE_VALUE_PROPERTY(QDMI_TELEMETRYSENSOR_PROPERTY_SAMPLINGRATE,
+                            uint64_t, telemetry_sensor->sampling_rate, prop,
+                            size, value, size_ret)
+  return QDMI_ERROR_NOTSUPPORTED;
+}
+
+int CXX_QDMI_device_session_create_device_telemetrysensor_query(
+    CXX_QDMI_Device_Session session,
+    CXX_QDMI_Device_TelemetrySensor_Query *query) {
+
+  if (session == nullptr || query == nullptr) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+  if (session->status != CXX_QDMI_DEVICE_SESSION_STATUS::INITIALIZED) {
+    return QDMI_ERROR_BADSTATE;
+  }
+  *query = new CXX_QDMI_Device_TelemetrySensor_Query_impl_d();
+  (*query)->start_time = std::chrono::system_clock::now();
+  (*query)->end_time = std::chrono::system_clock::now();
+  (*query)->status = QDMI_TELEMETRYSENSOR_QUERY_STATUS_CREATED;
+
+  return QDMI_SUCCESS;
+}
+
+int CXX_QDMI_device_telemetrysensor_query_set_parameter(
+    CXX_QDMI_Device_TelemetrySensor_Query query,
+    QDMI_Device_TelemetrySensor_Query_Parameter param, size_t size,
+    const void *value) {
+
+  if (query == nullptr || (value != nullptr && size == 0) ||
+      (param >= QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_MAX &&
+       param != QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_CUSTOM1 &&
+       param != QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_CUSTOM2 &&
+       param != QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_CUSTOM3 &&
+       param != QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_CUSTOM4 &&
+       param != QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_CUSTOM5) ||
+      value == nullptr || (size != sizeof(decltype(query->start_time)))) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+  switch (param) {
+
+  case QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_STARTTIME: {
+    query->start_time = std::chrono::system_clock::from_time_t(
+        *static_cast<const time_t *>(value));
+    return QDMI_SUCCESS;
+  }
+  case QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_ENDTIME: {
+    query->end_time = std::chrono::system_clock::from_time_t(
+        *static_cast<const time_t *>(value));
+    return QDMI_SUCCESS;
+  }
+
+  case QDMI_DEVICE_TELEMETRYSENSOR_QUERY_PARAMETER_TELEMETRYSENSOR: {
+    query->telemetry_sensor =
+        *(static_cast<const CXX_QDMI_TelemetrySensor *>(value));
+    return QDMI_SUCCESS;
+  }
+  default:
+    return QDMI_ERROR_NOTSUPPORTED;
+  }
+}
+
+int CXX_QDMI_device_telemetrysensor_query_submit(
+    CXX_QDMI_Device_TelemetrySensor_Query query) {
+
+  if (query == nullptr || query->telemetry_sensor == nullptr) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+
+  // here, the actual submission.
+
+  // for demonstration purposes
+  query->status = QDMI_TELEMETRYSENSOR_QUERY_STATUS_RUNNING;
+  // Clang-tidy generates a warning due to a known bug
+  // https://github.com/llvm/llvm-project/issues/98122
+  auto time_difference =
+      std::chrono::round<std::chrono::seconds>( // NOLINT(misc-include-cleaner)
+          query->end_time - query->start_time);
+
+  auto sampling_rate = query->telemetry_sensor->sampling_rate;
+
+  auto result_length =
+      static_cast<uint64_t>(time_difference.count()) / sampling_rate;
+  query->result_timestamps.clear();
+  query->result_timestamps.reserve(result_length);
+
+  query->result_values.clear();
+  query->result_values.reserve(result_length);
+
+  auto interval = std::chrono::seconds(sampling_rate);
+  for (unsigned int i = 0; i < result_length; i++) {
+
+    auto next_time = query->start_time + interval * i;
+    query->result_timestamps.emplace_back(next_time);
+
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_real_distribution<> dis(0.0, RAND_MAX);
+    query->result_values[i] = dis(gen);
+  }
+
+  return QDMI_SUCCESS;
+}
+
+int CXX_QDMI_device_telemetrysensor_query_get_results(
+    CXX_QDMI_Device_TelemetrySensor_Query query,
+    QDMI_TelemetrySensor_Query_Result result, size_t size, void *data,
+    size_t *size_ret) {
+
+  if (query == nullptr || (data != nullptr && size == 0) ||
+      (result >= QDMI_TELEMETRYSENSOR_QUERY_RESULT_MAX &&
+       result != QDMI_TELEMETRYSENSOR_QUERY_RESULT_CUSTOM1 &&
+       result != QDMI_TELEMETRYSENSOR_QUERY_RESULT_CUSTOM2 &&
+       result != QDMI_TELEMETRYSENSOR_QUERY_RESULT_CUSTOM3 &&
+       result != QDMI_TELEMETRYSENSOR_QUERY_RESULT_CUSTOM4 &&
+       result != QDMI_TELEMETRYSENSOR_QUERY_RESULT_CUSTOM5)) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+  size_t required_size = query->result_values.size();
+  switch (result) {
+  case QDMI_TELEMETRYSENSOR_QUERY_RESULT_TIMESTAMPS:
+    required_size *= sizeof(time_t);
+    if (data != nullptr) {
+      if (size < required_size) {
+        return QDMI_ERROR_INVALIDARGUMENT;
+      }
+      auto *data_ptr = static_cast<time_t *>(data);
+      for (auto timestamps : query->result_timestamps) {
+        *data_ptr++ = std::chrono::system_clock::to_time_t(timestamps);
+      }
+    }
+
+    if ((size_ret) != nullptr) {
+      *(size_ret) = required_size;
+    }
+    return QDMI_SUCCESS;
+  case QDMI_TELEMETRYSENSOR_QUERY_RESULT_VALUES:
+
+    required_size *= sizeof(double);
+    if (data != nullptr) {
+      if (size < required_size) {
+        return QDMI_ERROR_INVALIDARGUMENT;
+      }
+      memcpy(data, query->result_values.data(), required_size);
+    }
+    if ((size_ret) != nullptr) {
+      *(size_ret) = required_size;
+    }
+    return QDMI_SUCCESS;
+
+  default:
+    return QDMI_ERROR_NOTSUPPORTED;
+  }
+
+  return QDMI_SUCCESS;
+}
+
+int CXX_QDMI_device_telemetrysensor_query_check_status(
+    CXX_QDMI_Device_TelemetrySensor_Query query,
+    QDMI_TelemetrySensor_Query_Status *status) {
+  if (query == nullptr || status == nullptr) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+
+  // randomly decide whether job is done or not
+  if (query->status == QDMI_TELEMETRYSENSOR_QUERY_STATUS_RUNNING &&
+      CXX_QDMI_generate_bit()) {
+    query->status = QDMI_TELEMETRYSENSOR_QUERY_STATUS_DONE;
+  }
+
+  *status = query->status;
+  return QDMI_SUCCESS;
+}
+
+int CXX_QDMI_device_telemetrysensor_query_wait(
+    CXX_QDMI_Device_TelemetrySensor_Query query, size_t timeout) {
+
+  if (query == nullptr) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+
+  query->status = QDMI_TELEMETRYSENSOR_QUERY_STATUS_DONE;
+  query->timeout = std::chrono::seconds(timeout);
+  return QDMI_SUCCESS;
+}
+
+int CXX_QDMI_device_telemetrysensor_query_cancel(
+    CXX_QDMI_Device_TelemetrySensor_Query query) {
+
+  if (query == nullptr ||
+      query->status == QDMI_TELEMETRYSENSOR_QUERY_STATUS_DONE) {
+    return QDMI_ERROR_INVALIDARGUMENT;
+  }
+
+  query->status = QDMI_TELEMETRYSENSOR_QUERY_STATUS_CANCELED;
+
+  return QDMI_SUCCESS;
+}
+
+void CXX_QDMI_device_telemetrysensor_query_free(
+    CXX_QDMI_Device_TelemetrySensor_Query query) {
+  delete query;
+}