datasketches 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eadeb269a420be62fa48fbdc950bd5583cdfd1d74776b3e627be852f2551af89
-  data.tar.gz: 422aee84c37c94267c9e6222145eb0bad0f0530e6917faba42a8ef17f1079b69
+  metadata.gz: 6a91d4d694972af601b74f32fdec1d52fb48d6bf9ee0c16332219d3755afd4c6
+  data.tar.gz: 5ca86cc02447be6af32c4eb1368fb93641cca227781a4e7827f2b1d3d43532bc
 SHA512:
-  metadata.gz: de095d22fac5e124d9927178961aaf0c375e43020ffe23f448ae16f57b48725aea254076755c518588036ebfe66197ff31170e4ac08365b2d1608cc440a144af
-  data.tar.gz: 7f6dda2ab6190c1aa6527951406db4c57d58d2d8205bd5a13c61d50c2d0ed8c903a69d4dc2ccb805ba47d2b04c1cacc691dacef07f5c0228d83d5572e6fe805e
+  metadata.gz: aaafc9cff65cd3827524ee7ae9d32076471adaaf8c17924121c1ca8f303cc76beafbf3fbaae4dea31895f31265b1a522795b3e6905a8275ba1eb3ae329032153
+  data.tar.gz: 07ffe0606651871f0b10f4b31d383ef78db3c1fe2ae83021686e3ed835bb6f7437554ffe342f68f703bae799dae3176f391a0d3e642b42a620f160c079d5579d

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.5.3 (2026-10-07)
+
+- Updated DataSketches to 5.3.0
+
 ## 0.5.2 (2026-04-06)
 
 - Improved installation time

data/ext/datasketches/theta_wrapper.cpp

@@ -57,7 +57,7 @@ void init_theta(Rice::Module& m) {
         return builder.build();
       },
       Rice::Arg("lg_k")=datasketches::theta_constants::DEFAULT_LG_K, Rice::Arg("p")=1.0, Rice::Arg("seed")=DEFAULT_SEED)
-    .define_method("compact", &update_theta_sketch::compact, Rice::Arg("ordered")=true)
+    .define_method("compact", &update_theta_sketch::compact, Rice::Arg("ordered")=true, Rice::Arg("trim")=false)
     .define_method(
       "update",
       [](update_theta_sketch& self, Rice::Object datum) {

data/lib/datasketches/version.rb

@@ -1,3 +1,3 @@
 module DataSketches
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

data/vendor/datasketches-cpp/CMakeLists.txt

@@ -59,7 +59,7 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT CMAKE_CXX_COMPILER_VERSION VERS
   add_compile_options(-Wimplicit-fallthrough=3)
 endif()
 
-# Code generation options, to ensure shaerd libraries work and are portable
+# Code generation options, to ensure shared libraries work and are portable
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_C_EXTENSIONS OFF)
 set(CMAKE_CXX_EXTENSIONS OFF)
@@ -74,6 +74,8 @@ if (BUILD_TESTS)
   enable_testing()
 endif()
 
+option(BUILD_BENCHMARKS "Build benchmarks" OFF)
+
 option(COVERAGE "Enable code coverage reporting (g++/clang only)" OFF)
 if(COVERAGE AND CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
   set(CMAKE_BUILD_TYPE "Debug" FORCE)
@@ -121,8 +123,8 @@ add_subdirectory(density)
 add_subdirectory(tdigest)
 add_subdirectory(filters)
 
-if (WITH_PYTHON)
-  add_subdirectory(python)
+if (BUILD_BENCHMARKS)
+  add_subdirectory(benchmarks)
 endif()
 
 target_link_libraries(datasketches INTERFACE hll cpc kll fi theta sampling req quantiles count)

data/vendor/datasketches-cpp/CODE_OF_CONDUCT.md

@@ -1,3 +1,3 @@
 # Code of Conduct
 
-We adhere to the Apache Softare Foundation's [Code of Conduct](https://www.apache.org/foundation/policies/conduct).
+We adhere to the Apache Software Foundation's [Code of Conduct](https://www.apache.org/foundation/policies/conduct).

data/vendor/datasketches-cpp/LICENSE

@@ -296,3 +296,17 @@ APPENDIX B: Additional licenses relevant to this product.
     Code Locations:
       * common/include/ceiling_power_of_2.hpp
     that is adapted from the above.
+
+    =============================================================
+    FDLIBM
+    =============================================================
+    Original source code:
+      Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+      Developed at SunSoft, a Sun Microsystems, Inc. business.
+
+      Permission to use, copy, modify, and distribute this software is freely
+      granted, provided that this notice is preserved.
+
+    Code Locations:
+      common/include/fdlibm_log.hpp
+    that is adapted from __ieee754_log in FDLIBM 5.3.

data/vendor/datasketches-cpp/README.md

@@ -1,106 +1,100 @@
 # Apache DataSketches Core C++ Library Component
-This is the core C++ component of the Apache DataSketches library.  It contains all of the key sketching algorithms that are in the Java component and can be accessed directly from user applications. 
 
-This component is also a dependency of other components of the library that create adaptors for target systems, such as PostgreSQL.
+This is the core C++ component of the Apache DataSketches library.  It contains all the key sketching algorithms from the Java implementation and can be accessed directly by user applications. 
 
-Note that we have a parallel core component for [Java]((https://github.com/apache/datasketches-java) and [Python]((https://github.com/apache/datasketches-python) implementations of the same sketch algorithms.
+This component is also a dependency of other library components that create adaptors for target systems, such as [PostgreSQL](https://github.com/apache/datasketches-postgresql).
+
+Note that we have parallel core library components for Java, Python, GO, and Rust implementations of many of the same sketch algorithms:
+
+- [datasketches-java](https://github.com/apache/datasketches-java)
+- [datasketches-python](https://github.com/apache/datasketches-python)
+- [datasketches-go](https://github.com/apache/datasketches-go)
+- [datasketches-rust](https://github.com/apache/datasketches-rust)
 
 Please visit the main [Apache DataSketches website](https://datasketches.apache.org) for more information. 
 
-If you are interested in making contributions to this site please see our [Community](https://datasketches.apache.org/docs/Community/) page for how to contact us.
+If you are interested in making contributions to this site, please see our [Community](https://datasketches.apache.org/docs/Community/) page for how to contact us.
 
 ---
 
 This code requires C++11.
 
-This library is header-only. The build process provided is only for building unit tests.
+This library is header-only. The provided build process is only for unit tests.
 
-Building the unit tests requires cmake 3.12.0 or higher.
+Building the unit tests requires CMake 3.12.0 or higher.
 
-Installing the latest cmake on OSX: brew install cmake
+Installing the latest CMake on OSX: `brew install cmake`.
 
-Building and running unit tests using cmake for OSX and Linux:
+Building and running unit tests using CMake for OSX and Linux:
 
-```
-    $ cmake -S . -B build/Release -DCMAKE_BUILD_TYPE=Release
-    $ cmake --build build/Release -t all test
+```shell
+cmake -S . -B build/Release -DCMAKE_BUILD_TYPE=Release
+cmake --build build/Release -t all test
 ```
 
-Building and running unit tests using cmake for Windows from the command line:
+Building and running unit tests using CMake for Windows from the command line:
 
-```
-    $ cd build
-    $ cmake ..
-    $ cd ..
-    $ cmake --build build --config Release
-    $ cmake --build build --config Release --target RUN_TESTS
+```shell
+cd build
+cmake ..
+cd ..
+cmake --build build --config Release
+cmake --build build --config Release --target RUN_TESTS
 ```
 
-To install a local distribution (OSX and Linux), use the following command. The
-CMAKE_INSTALL_PREFIX variable controls the destination. If not specified, it 
-defaults to installing in /usr (/usr/include, /usr/lib, etc). In the command below,
-the installation will be in /tmp/install/DataSketches (/tmp/install/DataSketches/include,
-/tmp/install/DataSketches/lib, etc)
+To install a local distribution (OSX and Linux), use the following command. The `CMAKE_INSTALL_PREFIX` variable controls the destination. If not specified, it defaults to installing in /usr (/usr/include, /usr/lib, etc). In the command below, the installation will be in /tmp/install/DataSketches (/tmp/install/DataSketches/include, /tmp/install/DataSketches/lib, etc).
 
-```
-    $ cmake -S . -B build/Release -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/tmp/install/DataSketches
-    $ cmake --build build/Release -t install
+```shell
+cmake -S . -B build/Release -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/tmp/install/DataSketches
+cmake --build build/Release -t install
 ```
 
-To generate an installable package using cmake's built in cpack packaging tool,
-use the following command. The type of packaging is controlled by the CPACK_GENERATOR
-variable (semi-colon separated list). Cmake usually supports packaging types such as RPM,
-DEB, STGZ, TGZ, TZ, ZIP, etc.
+To generate an installable package using CMake's built-in cpack packaging tool, use the following command. The type of packaging is controlled by the `CPACK_GENERATOR` variable (semi-colon separated list). CMake usually supports packaging formats such as RPM, DEB, STGZ, TGZ, TZ, and ZIP.
 
-```
-    $ cmake3 -S . -B build/Release -DCMAKE_BUILD_TYPE=Release -DCPACK_GENERATOR="RPM;STGZ;TGZ" 
-    $ cmake3 --build build/Release -t package
+```shell
+cmake -S . -B build/Release -DCMAKE_BUILD_TYPE=Release -DCPACK_GENERATOR="RPM;STGZ;TGZ" 
+cmake --build build/Release -t package
 ```
 
 The DataSketches project can be included in other projects' CMakeLists.txt files in one of two ways.
-If DataSketches has been installed on the host (using an RPM, DEB, "make install" into /usr/local, or some 
-way, then CMake's `find_package` command can be used like this:
 
-```
-    find_package(DataSketches 3.2 REQUIRED)
-    target_link_library(my_dependent_target PUBLIC ${DATASKETCHES_LIB})
+If DataSketches has been installed on the host (using an RPM, DEB, "make install" into /usr/local, or some way, then CMake's `find_package` command can be used like this:
+
+```cmake
+find_package(DataSketches 3.2 REQUIRED)
+target_link_library(my_dependent_target PUBLIC ${DATASKETCHES_LIB})
 ```
 
 When used with find_package, DataSketches exports several variables, including
 
-   - `DATASKETCHES_VERSION`: The version number of the datasketches package that was imported.
-   - `DATASKETCHES_INCLUDE_DIR`: The directory that should be added to access DataSketches include files.
-   Because cmake automatically includes the interface directories for included target libraries when
-   using `target_link_library`, under normal circumstances there will be no need to include this directly.
-   - `DATASKETCHES_LIB`: The name of the DataSketches target to include as a dependency. Projects pulling
-   in DataSketches should reference this with `target_link_library` in order to set up all the correct dependencies 
-   and include paths.
-
-If you don't have DataSketches installed locally, dependent projects can pull it directly
-from GitHub using CMake's `ExternalProject` module. The code would look something like this:
-
-```
-    cmake_policy(SET CMP0097 NEW)
-    include(ExternalProject)
-    ExternalProject_Add(datasketches
-        GIT_REPOSITORY https://github.com/apache/datasketches-cpp.git
-        GIT_TAG 3.2.0
-        GIT_SHALLOW true
-        GIT_SUBMODULES ""
-        INSTALL_DIR /tmp/datasketches-prefix
-        CMAKE_ARGS -DBUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_INSTALL_PREFIX=/tmp/datasketches-prefix
-
-        # Override the install command to add DESTDIR
-        # This is necessary to work around an oddity in the RPM (but not other) package
-        # generation, as CMake otherwise picks up the Datasketch files when building
-        # an RPM for a dependent package. (RPM scans the directory for files in addition to installing
-        # those files referenced in an "install" rule in the cmake file)
-        INSTALL_COMMAND env DESTDIR= ${CMAKE_COMMAND} --build . --target install
-    )
-    ExternalProject_Get_property(datasketches INSTALL_DIR)
-    set(datasketches_INSTALL_DIR ${INSTALL_DIR})
-    message("Source dir of datasketches = ${datasketches_INSTALL_DIR}")
-    target_include_directories(my_dependent_target 
-                                PRIVATE ${datasketches_INSTALL_DIR}/include/DataSketches)
-    add_dependencies(my_dependent_target datasketches)
+- `DATASKETCHES_VERSION`: The version number of the datasketches package that was imported.
+- `DATASKETCHES_INCLUDE_DIR`: The directory that should be added to access DataSketches include files. Because CMake automatically includes the interface directories for included target libraries when using `target_link_library`, under normal circumstances, there will be no need to include this directly
+- `DATASKETCHES_LIB`: The name of the DataSketches target to include as a dependency. Projects pulling in DataSketches should reference this with `target_link_library` in order to set up all the correct dependencies and include paths.
+
+If you don't have DataSketches installed locally, dependent projects can pull it directly from GitHub using CMake's `ExternalProject` module. The code would look something like this:
+
+```cmake
+cmake_policy(SET CMP0097 NEW)
+include(ExternalProject)
+ExternalProject_Add(datasketches
+    GIT_REPOSITORY https://github.com/apache/datasketches-cpp.git
+    GIT_TAG 3.2.0
+    GIT_SHALLOW true
+    GIT_SUBMODULES ""
+    INSTALL_DIR /tmp/datasketches-prefix
+    CMAKE_ARGS -DBUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_INSTALL_PREFIX=/tmp/datasketches-prefix
+
+    # Override the install command to add DESTDIR
+    # This is necessary to work around an oddity in the RPM (but not other) package
+    # generation, as CMake otherwise picks up the Datasketch files when building
+    # an RPM for a dependent package. (RPM scans the directory for files in addition to installing
+    # those files referenced in an "install" rule in the cmake file)
+    INSTALL_COMMAND env DESTDIR= ${CMAKE_COMMAND} --build . --target install
+)
+ExternalProject_Get_property(datasketches INSTALL_DIR)
+set(datasketches_INSTALL_DIR ${INSTALL_DIR})
+message("Source dir of datasketches = ${datasketches_INSTALL_DIR}")
+target_include_directories(my_dependent_target 
+                            PRIVATE ${datasketches_INSTALL_DIR}/include/DataSketches)
+add_dependencies(my_dependent_target datasketches)
 ```

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

@@ -0,0 +1,52 @@
+# 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.
+
+if (NOT TARGET benchmark::benchmark_main)
+  include(FetchContent)
+
+  set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "Disable google-benchmark tests" FORCE)
+  set(BENCHMARK_ENABLE_GTEST_TESTS OFF CACHE BOOL "Disable google-benchmark gtest tests" FORCE)
+  set(BENCHMARK_ENABLE_INSTALL OFF CACHE BOOL "Disable google-benchmark install rules" FORCE)
+  set(BENCHMARK_INSTALL_DOCS OFF CACHE BOOL "Disable google-benchmark documentation install" FORCE)
+  set(BENCHMARK_ENABLE_WERROR OFF CACHE BOOL "Disable google-benchmark warnings as errors" FORCE)
+
+  FetchContent_Declare(
+    googlebenchmark
+    GIT_REPOSITORY https://github.com/google/benchmark.git
+    GIT_TAG        v1.7.1
+  )
+
+  FetchContent_MakeAvailable(googlebenchmark)
+endif()
+
+add_executable(count_min_sketch_benchmark)
+
+target_link_libraries(count_min_sketch_benchmark
+  PRIVATE
+    count
+    benchmark::benchmark_main
+)
+
+set_target_properties(count_min_sketch_benchmark PROPERTIES
+  CXX_STANDARD_REQUIRED YES
+)
+
+target_sources(count_min_sketch_benchmark
+  PRIVATE
+    benchmark_count_min_sketch.cpp
+    benchmark_count_min_sketch_serialization.cpp
+)

data/vendor/datasketches-cpp/benchmarks/benchmark_count_min_sketch.cpp

@@ -0,0 +1,153 @@
+/*
+ * 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 <benchmark/benchmark.h>
+#include <count_min.hpp>
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace
+{
+
+using Sketch = datasketches::count_min_sketch<uint64_t>;
+
+// Roughly 99.9% confidence and 0.1% relative error:
+// suggest_num_hashes(0.999) == 7 and suggest_num_buckets(0.001) == 2719.
+constexpr uint8_t NUM_HASHES = 7;
+constexpr uint32_t NUM_BUCKETS = 2719;
+
+std::vector<uint64_t> makeUInt64Keys(size_t size)
+{
+    std::vector<uint64_t> keys;
+    keys.reserve(size);
+    for (size_t i = 0; i < size; ++i)
+        keys.push_back(static_cast<uint64_t>(i * 0x9e3779b97f4a7c15ULL));
+    return keys;
+}
+
+std::vector<std::string> makeStringKeys(size_t size)
+{
+    std::vector<std::string> keys;
+    keys.reserve(size);
+    for (size_t i = 0; i < size; ++i)
+        keys.push_back("countmin-key-" + std::to_string(i * 2654435761ULL));
+    return keys;
+}
+
+int64_t totalStringBytes(const std::vector<std::string> & keys)
+{
+    int64_t bytes = 0;
+    for (const auto & key : keys)
+        bytes += static_cast<int64_t>(key.size());
+    return bytes;
+}
+
+void BM_CountMinUpdateUInt64(benchmark::State & state)
+{
+    const auto keys = makeUInt64Keys(static_cast<size_t>(state.range(0)));
+    for (auto _ : state)
+    {
+        state.PauseTiming();
+        Sketch sketch(NUM_HASHES, NUM_BUCKETS);
+        state.ResumeTiming();
+
+        for (const auto key : keys)
+            sketch.update(&key, sizeof(key), 1);
+
+        benchmark::ClobberMemory();
+        benchmark::DoNotOptimize(sketch.get_total_weight());
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<int64_t>(keys.size()));
+    state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(keys.size() * sizeof(uint64_t)));
+}
+
+void BM_CountMinUpdateStringBytes(benchmark::State & state)
+{
+    const auto keys = makeStringKeys(static_cast<size_t>(state.range(0)));
+    const auto bytes_per_iteration = totalStringBytes(keys);
+
+    for (auto _ : state)
+    {
+        state.PauseTiming();
+        Sketch sketch(NUM_HASHES, NUM_BUCKETS);
+        state.ResumeTiming();
+
+        for (const auto & key : keys)
+            sketch.update(key.data(), key.size(), 1);
+
+        benchmark::ClobberMemory();
+        benchmark::DoNotOptimize(sketch.get_total_weight());
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<int64_t>(keys.size()));
+    state.SetBytesProcessed(state.iterations() * bytes_per_iteration);
+}
+
+void BM_CountMinEstimateUInt64(benchmark::State & state)
+{
+    const auto keys = makeUInt64Keys(static_cast<size_t>(state.range(0)));
+    Sketch sketch(NUM_HASHES, NUM_BUCKETS);
+    for (const auto key : keys)
+        sketch.update(&key, sizeof(key), 1);
+
+    uint64_t sum = 0;
+    for (auto _ : state)
+    {
+        for (const auto key : keys)
+            sum += sketch.get_estimate(&key, sizeof(key));
+
+        benchmark::DoNotOptimize(sum);
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<int64_t>(keys.size()));
+    state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(keys.size() * sizeof(uint64_t)));
+}
+
+void BM_CountMinEstimateStringBytes(benchmark::State & state)
+{
+    const auto keys = makeStringKeys(static_cast<size_t>(state.range(0)));
+    const auto bytes_per_iteration = totalStringBytes(keys);
+
+    Sketch sketch(NUM_HASHES, NUM_BUCKETS);
+    for (const auto & key : keys)
+        sketch.update(key.data(), key.size(), 1);
+
+    uint64_t sum = 0;
+    for (auto _ : state)
+    {
+        for (const auto & key : keys)
+            sum += sketch.get_estimate(key.data(), key.size());
+
+        benchmark::DoNotOptimize(sum);
+    }
+
+    state.SetItemsProcessed(state.iterations() * static_cast<int64_t>(keys.size()));
+    state.SetBytesProcessed(state.iterations() * bytes_per_iteration);
+}
+
+}
+
+BENCHMARK(BM_CountMinUpdateUInt64)->RangeMultiplier(8)->Range(1024, 65536);
+BENCHMARK(BM_CountMinUpdateStringBytes)->RangeMultiplier(8)->Range(1024, 65536);
+BENCHMARK(BM_CountMinEstimateUInt64)->RangeMultiplier(8)->Range(1024, 65536);
+BENCHMARK(BM_CountMinEstimateStringBytes)->RangeMultiplier(8)->Range(1024, 65536);

data/vendor/datasketches-cpp/benchmarks/benchmark_count_min_sketch_serialization.cpp

@@ -0,0 +1,161 @@
+/*
+ * 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 <benchmark/benchmark.h>
+#include <count_min.hpp>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <ostream>
+#include <streambuf>
+#include <vector>
+
+namespace
+{
+
+using Sketch = datasketches::count_min_sketch<uint64_t>;
+
+// Roughly 99.9% confidence. Serialization cost then scales with the bucket count.
+constexpr uint8_t NUM_HASHES = 7;
+
+Sketch makeSketch(uint32_t num_buckets)
+{
+    Sketch sketch(NUM_HASHES, num_buckets);
+    for (uint64_t i = 0; i < NUM_HASHES; ++i)
+        sketch.update(i, i + 1);
+    return sketch;
+}
+
+class fixed_buffer_streambuf final: public std::streambuf
+{
+public:
+    explicit fixed_buffer_streambuf(std::vector<uint8_t>& buffer): buffer_(buffer), position_(0) {}
+
+    void reset()
+    {
+        position_ = 0;
+    }
+
+    size_t bytes_written() const
+    {
+        return position_;
+    }
+
+protected:
+    std::streamsize xsputn(const char* data, std::streamsize size) override
+    {
+        const size_t requested = static_cast<size_t>(size);
+        const size_t available = buffer_.size() - position_;
+        const size_t bytes_to_write = std::min(requested, available);
+        if (bytes_to_write > 0) {
+            std::memcpy(buffer_.data() + position_, data, bytes_to_write);
+            position_ += bytes_to_write;
+        }
+        return static_cast<std::streamsize>(bytes_to_write);
+    }
+
+    int_type overflow(int_type ch) override
+    {
+        if (traits_type::eq_int_type(ch, traits_type::eof()))
+            return traits_type::not_eof(ch);
+        if (position_ == buffer_.size())
+            return traits_type::eof();
+        buffer_[position_++] = static_cast<uint8_t>(traits_type::to_char_type(ch));
+        return ch;
+    }
+
+private:
+    std::vector<uint8_t>& buffer_;
+    size_t position_;
+};
+
+void BM_CountMinGetSerializedSizeBytes(benchmark::State& state)
+{
+    const auto sketch = makeSketch(static_cast<uint32_t>(state.range(0)));
+
+    for (auto _ : state) {
+        const auto size = sketch.get_serialized_size_bytes();
+        benchmark::DoNotOptimize(size);
+    }
+
+    state.SetItemsProcessed(state.iterations());
+}
+
+void BM_CountMinSerializeVector(benchmark::State& state)
+{
+    const auto sketch = makeSketch(static_cast<uint32_t>(state.range(0)));
+    const auto serialized_size = sketch.get_serialized_size_bytes();
+
+    for (auto _ : state) {
+        auto bytes = sketch.serialize();
+        benchmark::DoNotOptimize(bytes.data());
+        benchmark::DoNotOptimize(bytes.size());
+        benchmark::ClobberMemory();
+    }
+
+    state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(serialized_size));
+}
+
+void BM_CountMinSerializeOStream(benchmark::State& state)
+{
+    const auto sketch = makeSketch(static_cast<uint32_t>(state.range(0)));
+    const auto serialized_size = sketch.get_serialized_size_bytes();
+    std::vector<uint8_t> bytes(serialized_size);
+    fixed_buffer_streambuf stream_buffer(bytes);
+    std::ostream os(&stream_buffer);
+
+    for (auto _ : state) {
+        stream_buffer.reset();
+        os.clear();
+        sketch.serialize(os);
+        benchmark::DoNotOptimize(stream_buffer.bytes_written());
+        benchmark::ClobberMemory();
+    }
+
+    state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(serialized_size));
+}
+
+void BM_CountMinSerializeToSink(benchmark::State& state)
+{
+    const auto sketch = makeSketch(static_cast<uint32_t>(state.range(0)));
+    const auto serialized_size = sketch.get_serialized_size_bytes();
+    std::vector<uint8_t> bytes(serialized_size);
+
+    for (auto _ : state) {
+        uint8_t* ptr = bytes.data();
+        const auto bytes_written = sketch.serialize_to([&ptr](const void* data, size_t size) {
+            std::memcpy(ptr, data, size);
+            ptr += size;
+        });
+        benchmark::DoNotOptimize(ptr);
+        benchmark::DoNotOptimize(bytes_written);
+        benchmark::ClobberMemory();
+    }
+
+    state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(serialized_size));
+}
+
+}
+
+BENCHMARK(BM_CountMinGetSerializedSizeBytes)->RangeMultiplier(8)->Range(1024, 65536);
+BENCHMARK(BM_CountMinSerializeVector)->RangeMultiplier(8)->Range(1024, 65536);
+BENCHMARK(BM_CountMinSerializeOStream)->RangeMultiplier(8)->Range(1024, 65536);
+BENCHMARK(BM_CountMinSerializeToSink)->RangeMultiplier(8)->Range(1024, 65536);

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

@@ -40,6 +40,7 @@ install(FILES
       include/conditional_back_inserter.hpp
       include/conditional_forward.hpp
       include/count_zeros.hpp
+      include/fdlibm_log.hpp
       include/inv_pow2_table.hpp
       include/kolmogorov_smirnov_impl.hpp
       include/kolmogorov_smirnov.hpp

data/vendor/datasketches-cpp/common/include/binomial_bounds.hpp

@@ -441,8 +441,8 @@ private:
   }
 
   static void check_theta(double theta) {
-    if (theta < 0 || theta > 1) {
-      throw std::invalid_argument("theta must be in [0, 1]");
+    if (theta <= 0 || theta > 1) {
+      throw std::invalid_argument("theta must be in (0, 1]");
     }
   }