Added support for integer type master time channels. #101

include/mdf/iblock.h

@@ -34,7 +34,7 @@ class IBlock {
   /** \brief Returns the block type.
    *
    * The block type is 2 character string for example 'AT' and 'DT'. In MDF 4,
-   * the block type is actual 4 character but this function removes
+   * the block type is actually 4 characters but this function removes
    * the two first characters.
    * @return Block type (2 characters length).
    */

include/mdf/ichannel.h

@@ -375,7 +375,7 @@ class IChannel : public IBlock  {
    * @param values 1-Dimensional list of array values.
    */
   template<typename T>
-  void SetChannelValues(const std::vector<T>& value_array);
+  void SetChannelValues(const std::vector<T>& values);
 
   /** \brief Internally used function mainly for fetching VLSD index values.
    *
@@ -492,6 +492,29 @@ class IChannel : public IBlock  {
     value = std::to_string(sample);
     return true;
   }
+
+  /** \brief Defines if the master channel time should be calculated or not.
+   *
+   * If the channel is a master channel and the channel sync type is time,
+   * this option defines if its channel value should be calculated from
+   * the MdfWriter sample queue absolute time. Not used for reader applications.
+   *
+   * Default is the option set to true i.e. the channel value will be
+   * calculated from the absolute time in the writers sample queue. If
+   * it set to false, the user is responsible to set the channels value.
+   * @param calculate_master If set tp false, the user must set the channel value.
+   */
+  void CalculateMasterTime(bool calculate_master) {
+    calculate_master_time_ = calculate_master;
+  }
+
+  /** \brief Defines if the master channel time is calculated or user defined.
+   *
+   * @return True means that the master channel is calculated.
+   */
+  [[nodiscard]] bool CalculateMasterTime() const {
+    return calculate_master_time_;
+  }
  protected:
 
 
@@ -543,9 +566,11 @@ class IChannel : public IBlock  {
   /** \brief Support function that sets array values */
   virtual void SetByteArray(const std::vector<uint8_t> &value, bool valid);
 
+
  private:
 
   mutable uint64_t vlsd_record_id_ = 0; ///< Used to fix the VLSD CG block.
+  bool calculate_master_time_ = true; ///< If true, the master time channel will be calculated.
 };
 
 template <typename T>
@@ -690,7 +715,6 @@ void IChannel::SetChannelValue(const T &value, bool valid,
       }
       break;
 
-
     default:
       SetValid(false, array_index);
       break;

mdflib/src/dgrange.cpp

@@ -5,7 +5,6 @@
 /** \file
  * This file define the DG range support class.
  */
-#pragma once
 
 #include "dgrange.h"
 #include "mdf/ichannelgroup.h"

mdflib/src/ichannel.cpp

@@ -5,7 +5,7 @@
 #include <string>
 
 #include "bigbuffer.h"
-#include "half.hpp"
+// #include "half.hpp"
 #include "littlebuffer.h"
 #include "dbchelper.h"
 #include "mdf/ichannelgroup.h"
@@ -860,6 +860,76 @@ void IChannel::SetTimestamp(double timestamp,
   const size_t bytes = BitCount() / 8;
 
   switch (DataType()) {
+    case ChannelDataType::UnsignedIntegerBe:
+      if (timestamp < 0) {
+        timestamp = 0;
+      }
+      if (bytes == 1) {
+        const BigBuffer data(static_cast<uint8_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 2) {
+          const BigBuffer data(static_cast<uint16_t>(timestamp));
+          memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 4) {
+          const BigBuffer data(static_cast<uint32_t>(timestamp));
+          memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 8) {
+        const BigBuffer data(static_cast<uint64_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      }
+      break;
+
+    case ChannelDataType::UnsignedIntegerLe:
+      if (timestamp < 0) {
+        timestamp = 0;
+      }
+      if (bytes == 1) {
+        const LittleBuffer data(static_cast<uint8_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 2) {
+        const LittleBuffer data(static_cast<uint16_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 4) {
+        const LittleBuffer data(static_cast<uint32_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 8) {
+        const LittleBuffer data(static_cast<uint64_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      }
+      break;
+
+    case ChannelDataType::SignedIntegerBe:
+      if (bytes == 1) {
+        const BigBuffer data(static_cast<int8_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 2) {
+        const BigBuffer data(static_cast<int16_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 4) {
+        const BigBuffer data(static_cast<int32_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 8) {
+        const BigBuffer data(static_cast<int64_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      }
+      break;
+
+    case ChannelDataType::SignedIntegerLe:
+      if (bytes == 1) {
+        const LittleBuffer data(static_cast<int8_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 2) {
+        const LittleBuffer data(static_cast<int16_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 4) {
+        const LittleBuffer data(static_cast<int32_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      } else if (bytes == 8) {
+        const LittleBuffer data(static_cast<int64_t>(timestamp));
+        memcpy(record_buffer.data() + ByteOffset(), data.data(), bytes);
+      }
+      break;
+
     case ChannelDataType::FloatLe:
       if (bytes == 4) {
         const LittleBuffer data(static_cast<float>(timestamp));

mdflib/src/mdfwriter.cpp

@@ -194,7 +194,7 @@ void MdfWriter::SaveSample(const IChannelGroup& group, uint64_t time) {
   const auto itr_master = master_channels_.find(group.RecordId());
   const auto* master =
       itr_master == master_channels_.cend() ? nullptr : itr_master->second;
-  if (master != nullptr) {
+  if (master != nullptr && master->CalculateMasterTime()) {
     auto rel_ns = static_cast<int64_t>(sample.timestamp);
     rel_ns -= static_cast<int64_t>(start_time_);
     const double rel_s = static_cast<double>(rel_ns) / 1'000'000'000.0;
@@ -212,7 +212,7 @@ void MdfWriter::SaveCanMessage(const IChannelGroup& group, uint64_t time,
   const auto itr_master = master_channels_.find(group.RecordId());
   const auto* master =  itr_master == master_channels_.cend() ?
                                     nullptr : itr_master->second;
-  if (master != nullptr) {
+  if (master != nullptr && master->CalculateMasterTime()) {
     auto rel_ns = static_cast<int64_t>(sample.timestamp);
     rel_ns -= static_cast<int64_t>(start_time_);
     const double rel_s = static_cast<double>(rel_ns) / 1'000'000'000.0;
@@ -279,14 +279,14 @@ void MdfWriter::RecalculateTimeMaster() {
     if (itr_ch == master_channels_.end()) {
       continue;
     }
+    const auto* master = itr_ch->second;
+    if (master == nullptr || !master->CalculateMasterTime() ) {
+      continue;
+    }
     auto rel_ns = static_cast<int64_t>(sample.timestamp);
     rel_ns -= static_cast<int64_t>(start_time_);
     const double rel_s = static_cast<double>(rel_ns) / 1'000'000'000.0;
 
-    const auto* master = itr_ch->second;
-    if (master == nullptr) {
-      continue;
-    }
     master->SetTimestamp(rel_s, sample.record_buffer);
   }
 }

mdflib_test/CMakeLists.txt

@@ -31,7 +31,8 @@ add_executable(test_mdf
         src/testchannel.cpp
         src/testchannelarray.cpp
         src/testchannelarray.h
-        src/testxtensor.cpp)
+        src/testxtensor.cpp
+        src/testqueue.cpp)
 
 target_include_directories(test_mdf PRIVATE ../include ../mdflib/src)
 target_include_directories(test_mdf PRIVATE ${XTENSOR_INCLUDE_DIRS})

mdflib_test/src/testqueue.cpp

@@ -0,0 +1,69 @@
+/*
+* Copyright 2024 Ingemar Hedvall
+* SPDX-License-Identifier: MIT
+*/
+
+#include <gtest/gtest.h>
+#include <list>
+#include <deque>
+#include <queue>
+#include "mdf/samplerecord.h"
+#include "mdf/mdfhelper.h"
+
+using namespace mdf;
+
+
+namespace mdf::test {
+
+TEST(TestQueueSpeed, TestList) {
+  SampleRecord test_record;
+  test_record.timestamp = MdfHelper::NowNs();
+  test_record.record_id = 1;
+  test_record.record_buffer.resize(1000, 0);
+
+  std::cout << std::endl;
+  {
+    const uint64_t start_time = MdfHelper::NowNs();
+    std::list<SampleRecord> list;
+    for (size_t sample = 0; sample < 1'000'000; ++sample) {
+      list.push_back(test_record);
+    }
+    while (!list.empty()) {
+      list.pop_front();
+    }
+    const uint64_t run_time = MdfHelper::NowNs() - start_time;
+    std::cout << "List Run Time (ms): "
+              << static_cast<double>(run_time) / 1'000'000 << std::endl;
+  }
+
+  {
+    const uint64_t start_time = MdfHelper::NowNs();
+    std::deque<SampleRecord> list;
+    for (size_t sample = 0; sample < 1'000'000; ++sample) {
+      list.push_back(test_record);
+    }
+    while (!list.empty()) {
+      list.pop_front();
+    }
+    const uint64_t run_time = MdfHelper::NowNs() - start_time;
+    std::cout << "Deque Run Time (ms): "
+              << static_cast<double>(run_time) / 1'000'000 << std::endl;
+  }
+
+  {
+    const uint64_t start_time = MdfHelper::NowNs();
+    std::queue<SampleRecord> list;
+    for (size_t sample = 0; sample < 1'000'000; ++sample) {
+      list.push(test_record);
+    }
+    while (!list.empty()) {
+      list.pop();
+    }
+    const uint64_t run_time = MdfHelper::NowNs() - start_time;
+    std::cout << "Queue Run Time (ms): "
+              << static_cast<double>(run_time) / 1'000'000 << std::endl;
+  }
+  std::cout << std::endl;
+}
+
+} // end namespace mdf::test