datasketches 0.4.2 → 0.4.4

data/vendor/datasketches-cpp/filters/test/bloom_filter_test.cpp

@@ -0,0 +1,406 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <catch2/catch.hpp>
+
+#include "bloom_filter.hpp"
+
+#ifdef TEST_BINARY_INPUT_PATH
+static std::string testBinaryInputPath = TEST_BINARY_INPUT_PATH;
+#else
+static std::string testBinaryInputPath = "test/";
+#endif
+
+namespace datasketches {
+
+TEST_CASE("bloom_filter: invalid constructor args", "[bloom_filter]") {
+  REQUIRE_THROWS_AS(bloom_filter::builder::create_by_size(0, 4), std::invalid_argument);
+  REQUIRE_THROWS_AS(bloom_filter::builder::create_by_size(1L << 60, 4), std::invalid_argument);
+  REQUIRE_THROWS_AS(bloom_filter::builder::create_by_size(65535, 0), std::invalid_argument);
+}
+
+TEST_CASE("bloom_filter: standard constructors", "[bloom_filter]") {
+  uint64_t num_items = 4000;
+  double fpp = 0.01;
+
+  uint64_t num_bits = bloom_filter::builder::suggest_num_filter_bits(num_items, fpp);
+  uint16_t num_hashes = bloom_filter::builder::suggest_num_hashes(num_items, num_bits);
+  uint64_t seed = 89023;
+
+  auto bf = bloom_filter::builder::create_by_size(num_bits, num_hashes, seed);
+  uint64_t adjusted_num_bits = (num_bits + 63) & ~0x3F; // round up to the nearest multiple of 64
+  REQUIRE(bf.get_capacity() == adjusted_num_bits);
+  REQUIRE(bf.get_num_hashes() == num_hashes);
+  REQUIRE(bf.get_seed() == seed);
+  REQUIRE(bf.is_empty());
+
+  // should match above
+  bf = bloom_filter::builder::create_by_accuracy(num_items, fpp, seed);
+  REQUIRE(bf.get_capacity() == adjusted_num_bits);
+  REQUIRE(bf.get_num_hashes() == num_hashes);
+  REQUIRE(bf.get_seed() == seed);
+  REQUIRE(bf.is_empty());
+
+  // same for initializing memory in-place
+  size_t serialized_size_bytes = bloom_filter::get_serialized_size_bytes(num_bits);
+  uint8_t* bytes = new uint8_t[serialized_size_bytes];
+
+  bf = bloom_filter::builder::initialize_by_size(bytes, serialized_size_bytes, num_bits, num_hashes, seed);
+  REQUIRE(bf.get_capacity() == adjusted_num_bits);
+  REQUIRE(bf.get_num_hashes() == num_hashes);
+  REQUIRE(bf.get_seed() == seed);
+  REQUIRE(bf.is_empty());
+
+  bf = bloom_filter::builder::initialize_by_accuracy(bytes, serialized_size_bytes, num_items, fpp, seed);
+  REQUIRE(bf.get_capacity() == adjusted_num_bits);
+  REQUIRE(bf.get_num_hashes() == num_hashes);
+  REQUIRE(bf.get_seed() == seed);
+  REQUIRE(bf.is_empty());
+
+  delete [] bytes;
+}
+
+TEST_CASE("bloom_filter: basic operations", "[bloom_filter]") {
+  uint64_t num_items = 5000;
+  double fpp = 0.01;
+  uint64_t seed = 4897301548054ULL;
+
+  auto bf = bloom_filter::builder::create_by_accuracy(num_items, fpp, seed);
+  REQUIRE(bf.is_empty());
+  REQUIRE(bf.get_bits_used() == 0);
+
+  for (uint64_t i = 0; i < num_items; ++i) {
+    bf.query_and_update(i);
+  }
+
+  REQUIRE(!bf.is_empty());
+  // filter is about 50% full at target capacity
+  // since seed is fixed we expect an exact value every time
+  // but leaving the approximate test in since that's more the "expectation"
+  REQUIRE(bf.get_bits_used() == 24793); // exact value is not important but should be consistent
+  REQUIRE(bf.get_bits_used() == Approx(0.5 * bf.get_capacity()).epsilon(0.05)); // just over 3.3% in practice
+
+  uint32_t num_found = 0;
+  for (uint64_t i = num_items; i < bf.get_capacity(); ++i) {
+    if (bf.query(i)) {
+      ++num_found;
+    }
+  }
+  // fpp is average with significant variance -- even at 12% it would fail occasionally
+  REQUIRE(num_found == 423);
+  //REQUIRE(num_found == Approx((bf.get_capacity() - num_items) * fpp).epsilon(0.12));
+  auto bytes = bf.serialize();
+
+  // initialize in memory and run the same tests
+  // also checking against the results from the first part
+  uint8_t* bf_memory = new uint8_t[bytes.size()];
+  auto bf2 = bloom_filter::builder::initialize_by_accuracy(bf_memory, bytes.size(), num_items, fpp, bf.get_seed());
+  REQUIRE(bf2.is_empty());
+  REQUIRE(bf2.get_bits_used() == 0);
+
+  for (uint64_t i = 0; i < num_items; ++i) {
+    bf2.query_and_update(i);
+  }
+
+  REQUIRE(!bf2.is_empty());
+  REQUIRE(bf2.get_bits_used() == bf.get_bits_used()); // should exactly match above
+
+  uint32_t num_found2 = 0;
+  for (uint64_t i = num_items; i < bf2.get_capacity(); ++i) {
+    if (bf2.query(i)) {
+      ++num_found2;
+    }
+  }
+  REQUIRE(num_found == num_found2); // should exactly match above
+  auto bytes2 = bf2.serialize();
+
+  REQUIRE(bytes.size() == bytes2.size());
+  for (size_t i = 0; i < bytes.size(); ++i) {
+    REQUIRE(bytes[i] == bytes2[i]);
+  }
+
+  // check that raw memory also matches serialized sketch
+  const uint8_t* bf_bytes = bf2.get_wrapped_memory();
+  REQUIRE(bf_bytes == bf_memory);
+  for (size_t i = 0; i < bytes.size(); ++i) {
+    REQUIRE(bf_bytes[i] == bytes[i]);
+  }
+
+  // ensure the filters reset properly
+  bf.reset();
+  REQUIRE(bf.is_empty());
+  REQUIRE(bf.get_bits_used() == 0);
+
+  bf2.reset();
+  REQUIRE(bf2.is_empty());
+  REQUIRE(bf2.get_bits_used() == 0);
+
+  delete [] bf_memory;
+}
+
+TEST_CASE("bloom_filter: inversion", "[bloom_filter]") {
+  uint64_t num_bits = 8192;
+  uint16_t num_hashes = 3;
+
+  auto bf = bloom_filter::builder::create_by_size(num_bits, num_hashes);
+
+  uint64_t n = 500;
+  for (uint64_t i = 0; i < n; ++i) {
+    bf.update(i);
+  }
+  uint64_t num_bits_set = bf.get_bits_used();
+  bf.invert();
+  REQUIRE(bf.get_bits_used() == num_bits - num_bits_set);
+
+  // original items should be mostly not-present
+  uint32_t num_found = 0;
+  for (uint64_t i = 0; i < n; ++i) {
+    if (bf.query(i)) {
+      ++num_found;
+    }
+  }
+  REQUIRE(num_found < n / 10);
+
+  // many other items should be "present"
+  num_found = 0;
+  for (uint64_t i = n; i < num_bits; ++i) {
+    if (bf.query(i)) {
+      ++num_found;
+    }
+  }
+  REQUIRE(num_found > n);
+}
+
+TEST_CASE("bloom_filter: incompatible set operations", "[bloom_filter]") {
+  uint64_t num_bits = 32768;
+  uint16_t num_hashes = 4;
+
+  auto bf1 = bloom_filter::builder::create_by_size(num_bits, num_hashes);
+
+  // mismatched num bits
+  auto bf2 = bloom_filter::builder::create_by_size(2 * num_bits, num_hashes);
+  REQUIRE_THROWS_AS(bf1.union_with(bf2), std::invalid_argument);
+
+  // mismatched num hashes
+  auto bf3 = bloom_filter::builder::create_by_size(num_bits, 2 * num_hashes);
+  REQUIRE_THROWS_AS(bf1.intersect(bf2), std::invalid_argument);
+
+  // mismatched seed
+  auto bf4 = bloom_filter::builder::create_by_size(num_bits, num_hashes, bf1.get_seed() + 1);
+  REQUIRE_THROWS_AS(bf1.union_with(bf4), std::invalid_argument);
+}
+
+TEST_CASE("bloom_filter: basic union", "[bloom_filter]") {
+  const uint64_t num_bits = 12288;
+  const uint16_t num_hashes = 4;
+
+  auto bf1 = bloom_filter::builder::create_by_size(num_bits, num_hashes);
+  auto bf2 = bloom_filter::builder::create_by_size(num_bits, num_hashes, bf1.get_seed());
+
+  const uint64_t n = 1000;
+  const uint32_t max_item = 3 * n / 2 - 1;
+  for (uint64_t i = 0; i < n; ++i) {
+    bf1.query_and_update(i);
+    bf2.update(n / 2 + i);
+  }
+
+  bf1.union_with(bf2);
+  for (uint64_t i = 0; i < max_item; ++i) {
+    REQUIRE(bf1.query(i));
+  }
+
+  uint32_t num_found = 0;
+  for (uint64_t i = max_item; i < num_bits; ++i) {
+    if (bf1.query(i)) {
+      ++num_found;
+    }
+  }
+  REQUIRE(num_found < num_bits / 10); // not being super strict
+}
+
+TEST_CASE("bloom_filter: basic intersection", "[bloom_filter]") {
+  const uint64_t num_bits = 8192;
+  const uint16_t num_hahes = 5;
+
+  auto bf1 = bloom_filter::builder::create_by_size(num_bits, num_hahes);
+  auto bf2 = bloom_filter::builder::create_by_size(num_bits, num_hahes, bf1.get_seed());
+
+  const uint64_t n = 1024;
+  const uint32_t max_item = 3 * n / 2 - 1;
+  for (uint64_t i = 0; i < n; ++i) {
+    bf1.update(i);
+    bf2.update(n / 2 + i);
+  }
+
+  bf1.intersect(bf2);
+  // overlap bit should all be set
+  for (uint64_t i = n / 2; i < n; ++i) {
+    REQUIRE(bf1.query(i));
+  }
+
+  uint32_t num_found = 0;
+  for (uint64_t i = 0; i < n / 2; ++i) {
+    if (bf1.query(i)) {
+      ++num_found;
+    }
+  }
+  for (uint64_t i = max_item; i < num_bits; ++i) {
+    if (bf1.query(i)) {
+      ++num_found;
+    }
+  }
+
+  REQUIRE(num_found < num_bits / 10); // not being super strict
+}
+
+TEST_CASE("bloom_filter: empty serialization", "[bloom_filter]") {
+  const uint64_t num_bits = 32769;
+  const uint16_t num_hashes = 7;
+
+  auto bf = bloom_filter::builder::create_by_size(num_bits, num_hashes);
+  auto bytes = bf.serialize();
+  REQUIRE(bytes.size() == bf.get_serialized_size_bytes());
+
+  auto bf_bytes = bloom_filter::deserialize(bytes.data(), bytes.size());
+  REQUIRE(bf.get_capacity() == bf_bytes.get_capacity());
+  REQUIRE(bf.get_seed() == bf_bytes.get_seed());
+  REQUIRE(bf.get_num_hashes() == bf_bytes.get_num_hashes());
+  REQUIRE(bf_bytes.is_empty());
+
+  std::stringstream ss(std::ios::in | std::ios::out | std::ios::binary);
+  bf.serialize(ss);
+  auto bf_stream = bloom_filter::deserialize(ss);
+  REQUIRE(bf.get_capacity() == bf_stream.get_capacity());
+  REQUIRE(bf.get_seed() == bf_stream.get_seed());
+  REQUIRE(bf.get_num_hashes() == bf_stream.get_num_hashes());
+  REQUIRE(bf_stream.is_empty());
+
+  // read-only wrap should work
+  auto bf_wrap = bloom_filter::wrap(bytes.data(), bytes.size());
+  REQUIRE(bf.get_capacity() == bf_wrap.get_capacity());
+  REQUIRE(bf.get_seed() == bf_wrap.get_seed());
+  REQUIRE(bf.get_num_hashes() == bf_wrap.get_num_hashes());
+  REQUIRE(bf_wrap.is_empty());
+
+  // writable wrap should not
+  REQUIRE_THROWS_AS(bloom_filter::writable_wrap(bytes.data(), bytes.size()), std::invalid_argument);
+}
+
+TEST_CASE("bloom_filter: non-empty serialization", "[bloom_filter]") {
+  const uint64_t num_bits = 32768;
+  const uint16_t num_hashes = 5;
+
+  auto bf = bloom_filter::builder::create_by_size(num_bits, num_hashes);
+  const uint64_t n = 1000;
+  for (uint64_t i = 0; i < n; ++i) {
+    bf.update(0.5 + i); // testing floats
+  }
+
+  // test more items without updating, assuming some false positives
+  // so we can check that we get the same number of false positives
+  // with the same query items
+  uint64_t fp_count = 0;
+  for (uint64_t i = n; i < num_bits; ++i) {
+    fp_count += bf.query(0.5 + i) ? 1 : 0;
+  }
+
+  auto bytes = bf.serialize();
+  REQUIRE(bytes.size() == bf.get_serialized_size_bytes());
+
+  auto bf_bytes = bloom_filter::deserialize(bytes.data(), bytes.size());
+  REQUIRE(bf.get_capacity() == bf_bytes.get_capacity());
+  REQUIRE(bf.get_seed() == bf_bytes.get_seed());
+  REQUIRE(bf.get_num_hashes() == bf_bytes.get_num_hashes());
+  REQUIRE(!bf_bytes.is_empty());
+  REQUIRE(bf.is_memory_owned());
+  uint64_t fp_count_bytes = 0;
+  for (uint64_t i = 0; i < num_bits; ++i) {
+    bool val = bf_bytes.query(0.5 + i);
+    if (i < n)
+      REQUIRE(val);
+    else if (val)
+      ++fp_count_bytes;
+  }
+  REQUIRE(fp_count_bytes == fp_count);
+
+  std::stringstream ss(std::ios::in | std::ios::out | std::ios::binary);
+  bf.serialize(ss);
+  auto bf_stream = bloom_filter::deserialize(ss);
+  REQUIRE(bf.get_capacity() == bf_stream.get_capacity());
+  REQUIRE(bf.get_seed() == bf_stream.get_seed());
+  REQUIRE(bf.get_num_hashes() == bf_stream.get_num_hashes());
+  REQUIRE(!bf_stream.is_empty());
+  REQUIRE(bf_stream.is_memory_owned());
+  uint64_t fp_count_stream = 0;
+  for (uint64_t i = 0; i < num_bits; ++i) {
+    bool val = bf_stream.query(0.5 + i);
+    if (i < n)
+      REQUIRE(val);
+    else if (val)
+      ++fp_count_stream;
+  }
+  REQUIRE(fp_count_stream == fp_count);
+
+  // read-only wrap
+  auto bf_wrap = bloom_filter::wrap(bytes.data(), bytes.size());
+  REQUIRE(bf.get_capacity() == bf_wrap.get_capacity());
+  REQUIRE(bf.get_seed() == bf_wrap.get_seed());
+  REQUIRE(bf.get_num_hashes() == bf_wrap.get_num_hashes());
+  REQUIRE(!bf_wrap.is_empty());
+  REQUIRE(!bf_wrap.is_memory_owned());
+  uint64_t fp_count_wrap = 0;
+  for (uint64_t i = 0; i < num_bits; ++i) {
+    bool val = bf_wrap.query(0.5 + i);
+    if (i < n)
+      REQUIRE(val);
+    else if (val)
+      ++fp_count_wrap;
+  }
+  REQUIRE(fp_count_wrap == fp_count);
+  REQUIRE_THROWS_AS(bf_wrap.update(-1.0), std::logic_error);
+  REQUIRE_THROWS_AS(bf_wrap.query_and_update(-2.0), std::logic_error);
+  REQUIRE_THROWS_AS(bf_wrap.reset(), std::logic_error);
+
+  // writable wrap
+  auto bf_writable = bloom_filter::writable_wrap(bytes.data(), bytes.size());
+  REQUIRE(bf.get_capacity() == bf_writable.get_capacity());
+  REQUIRE(bf.get_seed() == bf_writable.get_seed());
+  REQUIRE(bf.get_num_hashes() == bf_writable.get_num_hashes());
+  REQUIRE(!bf_writable.is_empty());
+  REQUIRE(!bf_writable.is_memory_owned());
+  uint64_t fp_count_writable = 0;
+  for (uint64_t i = 0; i < num_bits; ++i) {
+    bool val = bf_writable.query(0.5 + i);
+    if (i < n)
+      REQUIRE(val);
+    else if (val)
+      ++fp_count_writable;
+  }
+  REQUIRE(fp_count_writable == fp_count);
+
+  REQUIRE(!bf_writable.query(-1.0));
+  bf_writable.update(-1.0);
+  REQUIRE(bf_writable.query(-1.0));
+
+  // not good memory management to do this, but because we wrapped the same bytes as both
+  // read-only adn writable, that update should ahve changed the read-only version, too
+  REQUIRE(bf_wrap.query(-1.0));
+}
+
+} // namespace datasketches

data/vendor/datasketches-cpp/hll/CMakeLists.txt

@@ -30,7 +30,6 @@ target_include_directories(hll
 )
 
 target_link_libraries(hll INTERFACE common)
-target_compile_features(hll INTERFACE cxx_std_11)
 
 install(TARGETS hll
   EXPORT ${PROJECT_NAME}

data/vendor/datasketches-cpp/kll/CMakeLists.txt

@@ -30,7 +30,6 @@ target_include_directories(kll
 )
 
 target_link_libraries(kll INTERFACE common)
-target_compile_features(kll INTERFACE cxx_std_11)
 
 install(TARGETS kll
   EXPORT ${PROJECT_NAME}

data/vendor/datasketches-cpp/kll/test/kll_sketch_custom_type_test.cpp

@@ -31,11 +31,14 @@ using alloc = test_allocator<test_type>;
 
 TEST_CASE("kll sketch custom type", "[kll_sketch]") {
 
-  // setup section
   test_allocator_total_bytes = 0;
+  test_allocator_net_allocations = 0;
 
   SECTION("compact level zero") {
     kll_test_type_sketch sketch(8, test_type_less(), 0);
+    REQUIRE(test_allocator_total_bytes != 0);
+    REQUIRE(test_allocator_net_allocations != 0);
+
     REQUIRE_THROWS_AS(sketch.get_quantile(0), std::runtime_error);
     REQUIRE_THROWS_AS(sketch.get_min_item(), std::runtime_error);
     REQUIRE_THROWS_AS(sketch.get_max_item(), std::runtime_error);
@@ -146,10 +149,8 @@ TEST_CASE("kll sketch custom type", "[kll_sketch]") {
     REQUIRE(sketch2.get_n() == 11);
   }
 
-  // cleanup
-  if (test_allocator_total_bytes != 0) {
-    REQUIRE(test_allocator_total_bytes == 0);
-  }
+  REQUIRE(test_allocator_total_bytes == 0);
+  REQUIRE(test_allocator_net_allocations == 0);
 }
 
 } /* namespace datasketches */

data/vendor/datasketches-cpp/quantiles/CMakeLists.txt

@@ -30,7 +30,6 @@ target_include_directories(quantiles
 )
 
 target_link_libraries(quantiles INTERFACE common)
-target_compile_features(quantiles INTERFACE cxx_std_11)
 
 install(TARGETS quantiles
   EXPORT ${PROJECT_NAME}

data/vendor/datasketches-cpp/req/CMakeLists.txt

@@ -30,7 +30,6 @@ target_include_directories(req
 )
 
 target_link_libraries(req INTERFACE common)
-target_compile_features(req INTERFACE cxx_std_11)
 
 install(TARGETS req
   EXPORT ${PROJECT_NAME}

data/vendor/datasketches-cpp/sampling/CMakeLists.txt

@@ -30,7 +30,6 @@ target_include_directories(sampling
 )
 
 target_link_libraries(sampling INTERFACE common)
-target_compile_features(sampling INTERFACE cxx_std_11)
 
 install(TARGETS sampling
   EXPORT ${PROJECT_NAME}

data/vendor/datasketches-cpp/sampling/include/ebpps_sample.hpp

@@ -37,14 +37,14 @@ class ebpps_sample {
   public:
     explicit ebpps_sample(uint32_t k, const A& allocator = A());
 
-    // constructor used to create a sample to merge one itme
-    template<typename TT>
-    ebpps_sample(TT&& item, double theta, const A& allocator = A());
-
     // for deserialization
     class items_deleter;
     ebpps_sample(std::vector<T, A>&& data, optional<T>&& partial_item, double c, const A& allocator = A());
 
+    // used instead of having a single-item constructor for update/merge calls
+    template<typename TT>
+    void replace_content(TT&& item, double theta);
+
     void reset();
     void downsample(double theta);
 

data/vendor/datasketches-cpp/sampling/include/ebpps_sample_impl.hpp

@@ -41,22 +41,6 @@ ebpps_sample<T,A>::ebpps_sample(uint32_t reserved_size, const A& allocator) :
     data_.reserve(reserved_size);
   }
 
-template<typename T, typename A>
-template<typename TT>
-ebpps_sample<T,A>::ebpps_sample(TT&& item, double theta, const A& allocator) :
-  allocator_(allocator),
-  c_(theta),
-  partial_item_(),
-  data_(allocator)
-  {
-    if (theta == 1.0) {
-      data_.reserve(1);
-      data_.emplace_back(std::forward<TT>(item));
-    } else {
-      partial_item_.emplace(std::forward<TT>(item));
-    }
-  }
-
 template<typename T, typename A>
 ebpps_sample<T,A>::ebpps_sample(std::vector<T, A>&& data, optional<T>&& partial_item, double c, const A& allocator) :
   allocator_(allocator),
@@ -65,6 +49,19 @@ ebpps_sample<T,A>::ebpps_sample(std::vector<T, A>&& data, optional<T>&& partial_
   data_(data, allocator)
   {}
 
+template<typename T, typename A>
+template<typename TT>
+void ebpps_sample<T,A>::replace_content(TT&& item, double theta) {
+  c_ = theta;
+  data_.clear();
+  partial_item_.reset();
+  if (theta == 1.0) {
+    data_.emplace_back(std::forward<TT>(item));
+  } else {
+    partial_item_.emplace(std::forward<TT>(item));
+  }
+}
+
 template<typename T, typename A>
 auto ebpps_sample<T,A>::get_sample() const -> result_type {
   double unused;

data/vendor/datasketches-cpp/sampling/include/ebpps_sketch.hpp

@@ -43,7 +43,7 @@ namespace ebpps_constants {
  * From: "Exact PPS Sampling with Bounded Sample Size",
  * B. Hentschel, P. J. Haas, Y. Tian. Information Processing Letters, 2023.
  * 
- * This sketch samples data from a stream of items propotional to the weight of each item.
+ * This sketch samples data from a stream of items proportional to the weight of each item.
  * The sample guarantees the presence of an item in the result is proportional to that item's
  * portion of the total weight seen by the sketch, and returns a sample no larger than size k.
  * 
@@ -256,6 +256,8 @@ class ebpps_sketch {
 
     ebpps_sample<T,A> sample_;      // Object holding the current state of the sample
 
+    ebpps_sample<T,A> tmp_;         // Temporary sample of size 1 used in updates
+
     // handles merge after ensuring other.cumulative_wt_ <= this->cumulative_wt_
     // so we can send items in individually
     template<typename O>

data/vendor/datasketches-cpp/sampling/include/ebpps_sketch_impl.hpp

@@ -40,7 +40,8 @@ ebpps_sketch<T, A>::ebpps_sketch(uint32_t k, const A& allocator) :
   cumulative_wt_(0.0),
   wt_max_(0.0),
   rho_(1.0),
-  sample_(check_k(k), allocator)
+  sample_(check_k(k), allocator),
+  tmp_(1, allocator)
   {}
 
 template<typename T, typename A>
@@ -53,7 +54,8 @@ ebpps_sketch<T,A>::ebpps_sketch(uint32_t k, uint64_t n, double cumulative_wt,
   cumulative_wt_(cumulative_wt),
   wt_max_(wt_max),
   rho_(rho),
-  sample_(sample)
+  sample_(sample),
+  tmp_(1, allocator)
   {}
 
 template<typename T, typename A>
@@ -148,9 +150,8 @@ void ebpps_sketch<T, A>::internal_update(FwdItem&& item, double weight) {
   if (cumulative_wt_ > 0.0)
     sample_.downsample(new_rho / rho_);
   
-  ebpps_sample<T,A> tmp(conditional_forward<FwdItem>(item), new_rho * weight, allocator_);
-
-  sample_.merge(tmp);
+  tmp_.replace_content(conditional_forward<FwdItem>(item), new_rho * weight);
+  sample_.merge(tmp_);
 
   cumulative_wt_ = new_cum_wt;
   wt_max_ = new_wt_max;
@@ -240,9 +241,8 @@ void ebpps_sketch<T, A>::internal_merge(O&& sk) {
     if (cumulative_wt_ > 0.0)
       sample_.downsample(new_rho / rho_);
   
-    ebpps_sample<T,A> tmp(conditional_forward<O>(items[i]), new_rho * avg_wt, allocator_);
-
-    sample_.merge(tmp);
+    tmp_.replace_content(conditional_forward<O>(items[i]), new_rho * avg_wt);
+    sample_.merge(tmp_);
 
     cumulative_wt_ = new_cum_wt;
     rho_ = new_rho;
@@ -259,9 +259,8 @@ void ebpps_sketch<T, A>::internal_merge(O&& sk) {
     if (cumulative_wt_ > 0.0)
       sample_.downsample(new_rho / rho_);
   
-    ebpps_sample<T,A> tmp(conditional_forward<O>(other_sample.get_partial_item()), new_rho * other_c_frac * avg_wt, allocator_);
-
-    sample_.merge(tmp);
+    tmp_.replace_content(conditional_forward<O>(other_sample.get_partial_item()), new_rho * other_c_frac * avg_wt);
+    sample_.merge(tmp_);
 
     cumulative_wt_ = new_cum_wt;
     rho_ = new_rho;

data/vendor/datasketches-cpp/sampling/test/ebpps_sample_test.cpp

@@ -42,14 +42,15 @@ TEST_CASE("ebpps sample: basic initialization", "[ebpps_sketch]") {
 
 TEST_CASE("ebpps sample: pre-initialized", "[ebpps_sketch]") {
   double theta = 1.0;
-  ebpps_sample<int> sample = ebpps_sample<int>(-1, theta);
+  ebpps_sample<int> sample(1);
+  sample.replace_content(-1, theta);
   REQUIRE(sample.get_c() == theta);
   REQUIRE(sample.get_num_retained_items() == 1);
   REQUIRE(sample.get_sample().size() == 1);
   REQUIRE(sample.has_partial_item() == false);
   
   theta = 1e-300;
-  sample = ebpps_sample<int>(-1, theta);
+  sample.replace_content(-1, theta);
   REQUIRE(sample.get_c() == theta);
   REQUIRE(sample.get_num_retained_items() == 1);
   REQUIRE(sample.get_sample().size() == 0); // assuming the random number is > 1e-300
@@ -57,7 +58,8 @@ TEST_CASE("ebpps sample: pre-initialized", "[ebpps_sketch]") {
 }
 
 TEST_CASE("ebpps sample: downsampling", "[ebpps_sketch]") {
-  ebpps_sample<char> sample = ebpps_sample<char>('a', 1.0);
+  ebpps_sample<char> sample(1);
+  sample.replace_content('a', 1.0);
 
   sample.downsample(2.0); // no-op
   REQUIRE(sample.get_c() == 1.0);
@@ -121,8 +123,9 @@ TEST_CASE("ebpps sample: merge unit samples", "[ebpps_sketch]") {
   uint32_t k = 8;
   ebpps_sample<int> sample = ebpps_sample<int>(k);
   
+  ebpps_sample<int> s(1);
   for (uint32_t i = 1; i <= k; ++i) {
-    ebpps_sample<int> s = ebpps_sample<int>(i, 1.0);
+    s.replace_content(i, 1.0);
     sample.merge(s);
     REQUIRE(sample.get_c() == static_cast<double>(i));
     REQUIRE(sample.get_num_retained_items() == i);