fix bad behavior when storing large moveable objects

Author: markisus

benchmarks.cc

@@ -10,25 +10,41 @@ std::default_random_engine gen;
 std::uniform_int_distribution<Id> sensor_id_gen(0, 100);
 std::uniform_int_distribution<Id> object_id_gen(0, 10);
 std::uniform_real_distribution<double> real_gen(-10.0, 10.0);
+std::uniform_int_distribution<int> char_gen('a', 'z');
 
-struct SensorData {
+
+struct ArraySensorData {
     std::array<double, 18> xyz;
 
-    static SensorData random() {
-        SensorData s;
+    static ArraySensorData random() {
+        ArraySensorData s;
         for (size_t i = 0; i < s.xyz.size(); ++i) {
             s.xyz[i] = real_gen(gen);
         }
         return s;
     };
 };
 
-template <typename... Ts>
-std::ostream& operator<<(std::ostream& cout, const SensorData& s) {
-    cout << "{" << s.xyz[0] << ", " << s.xyz[1] << ", " << s.xyz[2] << "}";
-    return cout;
-}
+struct StringSensorData {
+// contribution from greg7mdp during code review
+// for testing string data
+// https://github.com/markisus/vapid-soa/pull/3#issuecomment-1035390996
+    
+    std::string data;
+
+    static StringSensorData random() {
+        StringSensorData res;
+        char buff[31];
+        for (size_t i = 0; i < 30; ++i) {
+            buff[i] = char_gen(gen);
+        }       
+        buff[30] = 0;
+        res.data = buff;
+        return res;
+    };
+};
 
+template <typename SensorData>
 struct Measurement {
     Id sensor_id;
     Id object_id;
@@ -45,20 +61,15 @@ struct Measurement {
     }
 };
 
-template <typename... Ts>
-std::ostream& operator<<(std::ostream& cout, const Measurement& m) {
-    cout << "Measurement{" << m.sensor_id << ", " << m.object_id << ", " << m.timestamp << ", " << m.data << "}";
-    return cout;
-}
-
+template <typename SensorData>
 struct TestCase {
     vapid::soa<Id, Id, double, SensorData> measurements_soa;
-    std::vector<Measurement> measurements_vec;
+    std::vector<Measurement<SensorData>> measurements_vec;
 
     static TestCase random() {
         TestCase t;
         for (int i = 0; i < 100000; ++i) {
-            Measurement m = Measurement::random();
+            Measurement<SensorData> m = Measurement<SensorData>::random();
             t.measurements_vec.push_back(m);
             t.measurements_soa.insert(m.sensor_id, m.object_id, m.timestamp, m.data);
         }
@@ -67,23 +78,35 @@ struct TestCase {
     }
 };
 
-const TestCase random_data = TestCase::random();
+const auto random_array_data = TestCase<ArraySensorData>::random();
+const auto random_string_data = TestCase<StringSensorData>::random();
+
+static void BM_SoaSortBySensorId_ArrayData(benchmark::State& state) {
+    for (auto _ : state) {
+        state.PauseTiming();
+        auto soa = random_array_data.measurements_soa;
+        state.ResumeTiming();
+
+        soa.sort_by_field<0>();
+        benchmark::DoNotOptimize(soa.get_column<0>()[0]);
+    }
+}
 
-static void BM_SoaSortBySensorId(benchmark::State& state) {
+static void BM_SoaSortBySensorId_StringData(benchmark::State& state) {
     for (auto _ : state) {
         state.PauseTiming();
-        auto soa = random_data.measurements_soa;
+        auto soa = random_string_data.measurements_soa;
         state.ResumeTiming();
 
         soa.sort_by_field<0>();
         benchmark::DoNotOptimize(soa.get_column<0>()[0]);
     }
 }
 
-static void BM_VecSortBySensorId(benchmark::State& state) {
+static void BM_VecSortBySensorId_ArrayData(benchmark::State& state) {
     for (auto _ : state) {
         state.PauseTiming();
-        auto vec = random_data.measurements_vec;
+        auto vec = random_array_data.measurements_vec;
         state.ResumeTiming();
 
         std::stable_sort(vec.begin(),
@@ -95,8 +118,23 @@ static void BM_VecSortBySensorId(benchmark::State& state) {
     }
 }
 
-static void BM_SoaSumTimestamps(benchmark::State& state) {
-    const auto& soa = random_data.measurements_soa;
+static void BM_VecSortBySensorId_StringData(benchmark::State& state) {
+    for (auto _ : state) {
+        state.PauseTiming();
+        auto vec = random_string_data.measurements_vec;
+        state.ResumeTiming();
+
+        std::stable_sort(vec.begin(),
+                         vec.end(),
+                         [](auto& m1, auto& m2) {
+                             return m1.sensor_id < m2.sensor_id;
+                         });
+        benchmark::DoNotOptimize(vec[0]);
+    }
+}
+
+static void BM_SoaSumTimestamps_ArrayData(benchmark::State& state) {
+    const auto& soa = random_array_data.measurements_soa;
     for (auto _ : state) {
         double sum = 0;
         for (double d : soa.get_column<2>()) {
@@ -106,8 +144,8 @@ static void BM_SoaSumTimestamps(benchmark::State& state) {
     }
 }
 
-static void BM_VecSumTimestamps(benchmark::State& state) {
-    const auto& vec = random_data.measurements_vec;
+static void BM_VecSumTimestamps_ArrayData(benchmark::State& state) {
+    const auto& vec = random_array_data.measurements_vec;
     for (auto _ : state) {
         double sum = 0;
         for (const auto& meas : vec) {
@@ -119,9 +157,12 @@ static void BM_VecSumTimestamps(benchmark::State& state) {
 
 
 // Register the function as a benchmark
-BENCHMARK(BM_SoaSortBySensorId);
-BENCHMARK(BM_VecSortBySensorId);
-BENCHMARK(BM_SoaSumTimestamps);
-BENCHMARK(BM_VecSumTimestamps);
+BENCHMARK(BM_SoaSortBySensorId_ArrayData);
+BENCHMARK(BM_VecSortBySensorId_ArrayData);
+BENCHMARK(BM_SoaSortBySensorId_StringData);
+BENCHMARK(BM_VecSortBySensorId_StringData);
+
+BENCHMARK(BM_SoaSumTimestamps_ArrayData);
+BENCHMARK(BM_VecSumTimestamps_ArrayData);
 // Run the benchmark
 BENCHMARK_MAIN();

vapid/soa.h

@@ -202,7 +202,7 @@ namespace vapid {
             auto& dst = std::get<col_idx>(data_tmp_);
             dst.resize(src.size());
             for (size_t idx = 0; idx < src.size(); ++idx) {
-                dst[idx] = src[sort_order_reference_[idx]];
+                dst[idx] = std::move(src[sort_order_reference_[idx]]);
             }
             std::swap(src, dst);
         }