usearch 0.11.1 → 0.12.1

package/python/scripts/bench.py

@@ -102,7 +102,7 @@ def main(
         signature_f32 = types.float32(
             types.CPointer(types.float32),
             types.CPointer(types.float32),
-            types.size_t, types.size_t)
+            types.uint64, types.uint64)
 
         @cfunc(signature_f32)
         def inner_product_f32(a, b, n, m):
@@ -116,7 +116,7 @@ def main(
         signature_f8 = types.float32(
             types.CPointer(types.int8),
             types.CPointer(types.int8),
-            types.size_t, types.size_t)
+            types.uint64, types.uint64)
 
         @cfunc(signature_f8)
         def cos_f8(a, b, n, m):

package/python/scripts/test.py

@@ -1,31 +1,71 @@
+import os
 import pytest
 import numpy as np
 
-from usearch.io import load_matrix
-from usearch.index import Index, SetsIndex
+from usearch.io import load_matrix, save_matrix
+from usearch.index import Index, SetsIndex, MetricKind
+
 
 dimensions = [13, 99, 100, 256]
-sizes = [1, 2, 100]
-index_types = ['f64', 'f32', 'f16', 'f8']
-numpy_types = [np.float64, np.float32, np.float16, np.byte]
-connectivities = [3, 13, 50]
+batch_sizes = [1, 2, 100]
+index_types = ['f32', 'f64', 'f16', 'f8']
+numpy_types = [np.float32, np.float64, np.float16, np.byte]
+connectivity_options = [3, 13, 50]
+jit_options = [False]
+continuous_metrics = [
+    MetricKind.Cos,
+    MetricKind.L2sq,
+]
+hash_metrics = [
+    MetricKind.BitwiseHamming,
+    MetricKind.BitwiseTanimoto,
+    MetricKind.BitwiseSorensen,
+]
+
+
+@pytest.mark.parametrize('rows', batch_sizes)
+@pytest.mark.parametrize('cols', dimensions)
+def test_serializing_fbin_matrix(rows: int, cols: int):
+    original = np.random.rand(rows, cols).astype(np.float32)
+    save_matrix(original, 'tmp.fbin')
+    reconstructed = load_matrix('tmp.fbin')
+    assert np.allclose(original, reconstructed)
+    os.remove('tmp.fbin')
+
+
+@pytest.mark.parametrize('rows', batch_sizes)
+@pytest.mark.parametrize('cols', dimensions)
+def test_serializing_ibin_matrix(rows: int, cols: int):
+    original = np.random.randint(0, rows+1, size=(rows, cols)).astype(np.int32)
+    save_matrix(original, 'tmp.ibin')
+    reconstructed = load_matrix('tmp.ibin')
+    assert np.allclose(original, reconstructed)
+    os.remove('tmp.ibin')
 
 
 @pytest.mark.parametrize('ndim', dimensions)
+@pytest.mark.parametrize('metric', continuous_metrics)
 @pytest.mark.parametrize('index_type', index_types)
 @pytest.mark.parametrize('numpy_type', numpy_types)
-@pytest.mark.parametrize('connectivity', connectivities)
-def test_l2sq(ndim: int, index_type: str, numpy_type: str, connectivity: int):
+@pytest.mark.parametrize('connectivity', connectivity_options)
+@pytest.mark.parametrize('jit', jit_options)
+def test_index(
+        ndim: int, metric: MetricKind,
+        index_type: str, numpy_type: str,
+        connectivity: int, jit: bool):
+
     index = Index(
-        metric='l2sq',
+        metric=metric,
         ndim=ndim,
         dtype=index_type,
         connectivity=connectivity,
+        jit=jit,
     )
     assert index.ndim == ndim
     assert index.connectivity == connectivity
 
-    vector = np.random.uniform(0, 0.7, (index.ndim)).astype(numpy_type)
+    limit = 0.7 if numpy_type != np.byte else 70
+    vector = np.random.uniform(0, limit, (index.ndim)).astype(numpy_type)
     index.add(42, vector)
     matches, distances, count = index.search(vector, 10)
 
@@ -45,25 +85,31 @@ def test_l2sq(ndim: int, index_type: str, numpy_type: str, connectivity: int):
 
 
 @pytest.mark.parametrize('ndim', dimensions)
-@pytest.mark.parametrize('size', sizes)
+@pytest.mark.parametrize('metric', continuous_metrics)
+@pytest.mark.parametrize('batch_size', batch_sizes)
 @pytest.mark.parametrize('index_type', index_types)
 @pytest.mark.parametrize('numpy_type', numpy_types)
-def test_l2sq_batch(ndim: int, size: int, index_type: str, numpy_type: str):
-    index = Index(ndim=ndim, metric='l2sq', dtype=index_type)
+def test_index_batch(
+        ndim: int, metric: MetricKind,
+        batch_size: int, index_type: str, numpy_type: str):
 
-    vectors = np.random.uniform(0, 0.7, (size, index.ndim)).astype(numpy_type)
-    labels = np.array(range(size), dtype=np.longlong)
+    index = Index(ndim=ndim, metric=metric, dtype=index_type)
+
+    limit = 0.7 if numpy_type != np.byte else 70
+    vectors = np.random.uniform(
+        0, limit, (batch_size, index.ndim)).astype(numpy_type)
+    labels = np.array(range(batch_size), dtype=np.longlong)
 
     index.add(labels, vectors)
     matches, distances, count = index.search(vectors, 10)
 
     assert matches.shape[0] == distances.shape[0]
-    assert count.shape[0] == size
+    assert count.shape[0] == batch_size
 
 
 @pytest.mark.parametrize('ndim', dimensions)
-@pytest.mark.parametrize('size', sizes)
-def test_user_defined_function(ndim: int, size: int):
+@pytest.mark.parametrize('batch_size', batch_sizes)
+def test_index_udf(ndim: int, batch_size: int):
 
     try:
         from numba import cfunc, types, carray
@@ -75,7 +121,7 @@ def test_user_defined_function(ndim: int, size: int):
     signature = types.float32(
         types.CPointer(types.float32),
         types.CPointer(types.float32),
-        types.size_t, types.size_t)
+        types.uint64, types.uint64)
 
     @cfunc(signature)
     def python_dot(a, b, n, m):
@@ -86,27 +132,40 @@ def test_user_defined_function(ndim: int, size: int):
             c += a_array[i] * b_array[i]
         return c
 
-    index = Index(ndim=ndim, metric=python_dot.address)
+    index = Index(ndim=ndim, metric=python_dot)
 
     vectors = np.random.uniform(
-        0, 0.3, (size, index.ndim)).astype(np.float32)
-    labels = np.array(range(size), dtype=np.longlong)
+        0, 0.3, (batch_size, index.ndim)).astype(np.float32)
+    labels = np.array(range(batch_size), dtype=np.longlong)
 
     index.add(labels, vectors)
     matches, distances, count = index.search(vectors, 10)
 
     assert matches.shape[0] == distances.shape[0]
-    assert count.shape[0] == size
+    assert count.shape[0] == batch_size
 
 
-def test_sets():
+@pytest.mark.parametrize('connectivity', connectivity_options)
+def test_sets_index(connectivity: int):
 
-    index = SetsIndex()
+    index = SetsIndex(connectivity=connectivity)
     index.add(10, np.array([10, 12, 15], dtype=np.uint32))
     index.add(11, np.array([11, 12, 15, 16], dtype=np.uint32))
-    # results = index.search(np.array([12, 15], dtype=np.uint32), 10)
-    # assert list(results) == [10, 11]
+    results = index.search(np.array([12, 15], dtype=np.uint32), 10)
+    assert list(results) == [10, 11]
+
+
+@pytest.mark.parametrize('bits', dimensions)
+@pytest.mark.parametrize('metric', hash_metrics)
+@pytest.mark.parametrize('connectivity', connectivity_options)
+@pytest.mark.parametrize('batch_size', batch_sizes)
+def test_hash_index(bits: int, metric: MetricKind, connectivity: int, batch_size: int):
+
+    index = Index(ndim=bits, metric=metric, connectivity=connectivity)
 
+    bit_vectors = np.random.randint(2, size=(batch_size, bits))
+    bit_vectors = np.packbits(bit_vectors, axis=1)
+    labels = np.array(range(batch_size), dtype=np.longlong)
 
-if __name__ == '__main__':
-    pass
+    index.add(labels, bit_vectors)
+    index.search(bit_vectors, 10)

package/python/usearch/index.py

@@ -10,11 +10,22 @@ import numpy as np
 
 from usearch.compiled import Index as _CompiledIndex
 from usearch.compiled import SetsIndex as _CompiledSetsIndex
-from usearch.compiled import HashIndex as _CompiledHashIndex
-from usearch.compiled import DEFAULT_CONNECTIVITY, DEFAULT_EXPANSION_ADD, DEFAULT_EXPANSION_SEARCH
+from usearch.compiled import BitsIndex as _CompiledBitsIndex
+
+from usearch.compiled import MetricKind
+from usearch.compiled import (
+    DEFAULT_CONNECTIVITY,
+    DEFAULT_EXPANSION_ADD,
+    DEFAULT_EXPANSION_SEARCH,
+)
+
+BitwiseMetricKind = (
+    MetricKind.BitwiseHamming,
+    MetricKind.BitwiseTanimoto,
+    MetricKind.BitwiseSorensen,
+)
 
 SetsIndex = _CompiledSetsIndex
-HashIndex = _CompiledHashIndex
 
 
 class Matches(NamedTuple):
@@ -34,7 +45,7 @@ def list_matches(results: Matches, row: int) -> List[dict]:
     ]
 
 
-def jit_metric(ndim: int, metric_name: str, accuracy: str = 'f32') -> Callable:
+def jit_metric(ndim: int, metric: MetricKind, dtype: str = 'f32') -> Callable:
 
     try:
         from numba import cfunc, types, carray
@@ -46,26 +57,28 @@ def jit_metric(ndim: int, metric_name: str, accuracy: str = 'f32') -> Callable:
     # Showcases how to use Numba to JIT-compile similarity measures for USearch.
     # https://numba.readthedocs.io/en/stable/reference/jit-compilation.html#c-callbacks
 
-    if accuracy == 'f32':
+    if dtype == 'f32':
         signature = types.float32(
             types.CPointer(types.float32),
             types.CPointer(types.float32),
-            types.size_t, types.size_t)
+            types.uint64, types.uint64)
 
-        if metric_name == 'ip':
+        if metric == MetricKind.IP:
 
+            @cfunc(signature)
             def numba_ip(a, b, _n, _m):
                 a_array = carray(a, ndim)
                 b_array = carray(b, ndim)
                 ab = 0.0
                 for i in range(ndim):
                     ab += a_array[i] * b_array[i]
-                return ab
+                return 1 - ab
 
-            return cfunc(numba_ip, signature)
+            return numba_ip
 
-        if metric_name == 'cos':
+        if metric == MetricKind.Cos:
 
+            @cfunc(signature)
             def numba_cos(a, b, _n, _m):
                 a_array = carray(a, ndim)
                 b_array = carray(b, ndim)
@@ -76,28 +89,36 @@ def jit_metric(ndim: int, metric_name: str, accuracy: str = 'f32') -> Callable:
                     ab += a_array[i] * b_array[i]
                     a_sq += a_array[i] * a_array[i]
                     b_sq += b_array[i] * b_array[i]
-                return ab / (sqrt(a_sq) * sqrt(b_sq))
+                a_norm = sqrt(a_sq)
+                b_norm = sqrt(b_sq)
+                if a_norm == 0 and b_norm == 0:
+                    return 0
+                elif a_norm == 0 or b_norm == 0 or ab == 0:
+                    return 1
+                else:
+                    return 1 - ab / (a_norm * b_norm)
 
-            return cfunc(numba_cos, signature)
+            return numba_cos
 
-        if metric_name == 'l2sq':
+        if metric == MetricKind.L2sq:
 
+            @cfunc(signature)
             def numba_l2sq(a, b, _n, _m):
                 a_array = carray(a, ndim)
                 b_array = carray(b, ndim)
-                ab_delta_sq = 0.0
+                ab_delta_sq = types.float32(0.0)
                 for i in range(ndim):
                     ab_delta_sq += (a_array[i] - b_array[i]) * \
                         (a_array[i] - b_array[i])
                 return ab_delta_sq
 
-            return cfunc(numba_l2sq, signature)
+            return numba_l2sq
 
     return None
 
 
 class Index:
-    """Fast JIT-compiled index for equi-dimensional embeddings.
+    """Fast JIT-compiled vector-search index for dense equi-dimensional embeddings.
 
     Vector labels must be integers.
     Vectors must have the same number of dimensions within the index.
@@ -109,8 +130,8 @@ class Index:
     def __init__(
         self,
         ndim: int,
-        dtype: str = 'f32',
-        metric: Union[str, int] = 'ip',
+        metric: Union[MetricKind, Callable] = MetricKind.IP,
+        dtype: Optional[str] = None,
         jit: bool = False,
 
         connectivity: int = DEFAULT_CONNECTIVITY,
@@ -125,16 +146,21 @@ class Index:
 
         :param ndim: Number of vector dimensions
         :type ndim: int
-        :param dtype: Scalar type for vectors, defaults to 'f32'
+
+        :param metric: Distance function, defaults to MetricKind.IP
+        :type metric: Union[MetricKind, Callable], optional
+            Kind of the distance function, or the Numba `cfunc` JIT-compiled object.
+            Possible `MetricKind` values: IP, Cosine, L2sq, Haversine, 
+            Hamming, Tanimoto, Sorensen.
+            Not every kind is JIT-able.
+
+        :param dtype: Scalar type for internal vector storage, defaults to None
         :type dtype: str, optional
-            Example: you can use the `f16` index with `f32` vectors,
+            For continuous metrics can be: f16, f32, f64, or f8.
+            For bitwise metrics it's implementation-defined, and can't change.
+            Example: you can use the `f16` index with `f32` vectors in Euclidean space,
             which will be automatically downcasted.
 
-        :param metric: Distance function, defaults to 'ip'
-        :type metric: Union[str, int], optional
-            Name of distance function, or the address of the
-            Numba `cfunc` JIT-compiled object.
-
         :param jit: Enable Numba to JIT compile the metric, defaults to False
         :type jit: bool, optional
             This can result in up-to 3x performance difference on very large vectors
@@ -167,40 +193,54 @@ class Index:
         :param view: Are we simply viewing an immutable index, defaults to False
         :type view: bool, optional
         """
-        if jit:
-            assert isinstance(metric, str), 'Name the metric to JIT'
-            self._metric_name = metric
-            self._metric_jit = jit_metric(
+
+        if metric is None:
+            metric = MetricKind.IP
+
+        if isinstance(metric, Callable):
+            self._metric_kind = MetricKind.Unknown
+            self._metric_jit = metric
+            self._metric_pointer = int(metric.address)
+
+        elif isinstance(metric, MetricKind):
+            if jit:
+                self._metric_kind = metric
+                self._metric_jit = jit_metric(
+                    ndim=ndim,
+                    metric_kind=metric,
+                    dtype=dtype,
+                )
+                self._metric_pointer = self._metric_jit.address if \
+                    self._metric_jit else 0
+            else:
+                self._metric_kind = metric
+                self._metric_jit = None
+                self._metric_pointer = 0
+        else:
+            raise ValueError(
+                'The `metric` must be Numba callback or a `MetricKind`')
+
+        if metric in BitwiseMetricKind:
+            self._compiled = _CompiledBitsIndex(
+                bits=ndim,
+                metric=self._metric_kind,
+                connectivity=connectivity,
+                expansion_add=expansion_add,
+                expansion_search=expansion_search,
+            )
+        else:
+            if dtype is None:
+                dtype = 'f32'
+            self._compiled = _CompiledIndex(
                 ndim=ndim,
-                metric_name=metric,
+                metric=self._metric_kind,
+                metric_pointer=self._metric_pointer,
                 dtype=dtype,
+                connectivity=connectivity,
+                expansion_add=expansion_add,
+                expansion_search=expansion_search,
+                tune=tune,
             )
-            self._metric_pointer = self._metric_jit.address if \
-                self._metric_jit else 0
-
-        elif isinstance(metric, int):
-            self._metric_name = ''
-            self._metric_jit = None
-            self._metric_pointer = metric
-
-        else:
-            if metric is None:
-                metric = 'ip'
-            assert isinstance(metric, str)
-            self._metric_name = metric
-            self._metric_jit = None
-            self._metric_pointer = 0
-
-        self._compiled = _CompiledIndex(
-            ndim=ndim,
-            metric=self._metric_name,
-            metric_pointer=self._metric_pointer,
-            dtype=dtype,
-            connectivity=connectivity,
-            expansion_add=expansion_add,
-            expansion_search=expansion_search,
-            tune=tune,
-        )
 
         self.path = path
         if path and os.path.exists(path):
@@ -235,21 +275,56 @@ class Index:
         :param threads: Optimal number of cores to use, defaults to 0
         :type threads: int, optional
         """
+        assert isinstance(vectors, np.ndarray), 'Expects a NumPy array'
+        assert vectors.ndim == 1 or vectors.ndim == 2, 'Expects a matrix or vector'
+        is_batch = vectors.ndim == 2
+        generate_labels = labels is None
+
+        # If no `labels` were provided, generate some
+        if generate_labels:
+            start_id = len(self._compiled)
+            if is_batch:
+                labels = np.arange(start_id, start_id + vectors.shape[0])
+            else:
+                labels = start_id
         if isinstance(labels, np.ndarray):
             labels = labels.astype(np.longlong)
+
         self._compiled.add(labels, vectors, copy=copy, threads=threads)
 
+        if generate_labels:
+            return labels
+
     def search(
             self, vectors, k: int = 10, *,
             threads: int = 0, exact: bool = False) -> Matches:
+        """Performs approximate nearest neighbors search for one or more queries.
+
+        :param vectors: Query vector or vectors.
+        :type vectors: Buffer
+        :param k: Upper limit on the number of matches to find, defaults to 10
+        :type k: int, optional
+
+        :param threads: Optimal number of cores to use, defaults to 0
+        :type threads: int, optional
+        :param exact: Perform exhaustive linear-time exact search, defaults to False
+        :type exact: bool, optional
+        :return: Approximate matches for one or more queries
+        :rtype: Matches
+        """
         tuple_ = self._compiled.search(
             vectors, k,
-            exact=exact, threads=threads)
+            exact=exact, threads=threads,
+        )
         return Matches(*tuple_)
 
     def __len__(self) -> int:
         return len(self._compiled)
 
+    @property
+    def jit(self) -> bool:
+        return self._metric_jit is not None
+
     @property
     def size(self) -> int:
         return self._compiled.size

package/rust/lib.cpp

@@ -5,44 +5,50 @@ using namespace unum::usearch;
 using namespace unum;
 
 using punned_t = typename Index::punned_t;
+using add_result_t = typename punned_t::add_result_t;
+using search_result_t = typename punned_t::search_result_t;
+using serialization_result_t = typename punned_t::serialization_result_t;
 
-Index::Index(std::shared_ptr<punned_t> index) : index_(index) {}
+Index::Index(std::unique_ptr<punned_t> index) : index_(std::move(index)) {}
 
 void Index::add_in_thread(uint32_t label, rust::Slice<float const> vector, size_t thread) const {
     add_config_t config;
     config.thread = thread;
-    index_->add(label, vector.data(), config);
+    index_->add(label, vector.data(), config).error.raise();
 }
 
 Matches Index::search_in_thread(rust::Slice<float const> vector, size_t count, size_t thread) const {
-    Matches results;
-    results.labels.reserve(count);
-    results.distances.reserve(count);
+    Matches matches;
+    matches.labels.reserve(count);
+    matches.distances.reserve(count);
     for (size_t i = 0; i != count; ++i)
-        results.labels.push_back(0), results.distances.push_back(0);
+        matches.labels.push_back(0), matches.distances.push_back(0);
     search_config_t config;
     config.thread = thread;
-    results.count =
-        index_->search(vector.data(), count, config).dump_to(results.labels.data(), results.distances.data());
-    results.labels.truncate(results.count);
-    results.distances.truncate(results.count);
-    return results;
+    search_result_t result = index_->search(vector.data(), count, config);
+    result.error.raise();
+    matches.count = result.dump_to(matches.labels.data(), matches.distances.data());
+    matches.labels.truncate(matches.count);
+    matches.distances.truncate(matches.count);
+    return matches;
 }
 
 void Index::add(uint32_t label, rust::Slice<float const> vector) const {
-    index_->add(label, vector.data()); //
+    index_->add(label, vector.data()).error.raise();
 }
 
 Matches Index::search(rust::Slice<float const> vector, size_t count) const {
-    Matches results;
-    results.labels.reserve(count);
-    results.distances.reserve(count);
+    Matches matches;
+    matches.labels.reserve(count);
+    matches.distances.reserve(count);
     for (size_t i = 0; i != count; ++i)
-        results.labels.push_back(0), results.distances.push_back(0);
-    results.count = index_->search(vector.data(), count).dump_to(results.labels.data(), results.distances.data());
-    results.labels.truncate(results.count);
-    results.distances.truncate(results.count);
-    return results;
+        matches.labels.push_back(0), matches.distances.push_back(0);
+    search_result_t result = index_->search(vector.data(), count);
+    result.error.raise();
+    matches.count = result.dump_to(matches.labels.data(), matches.distances.data());
+    matches.labels.truncate(matches.count);
+    matches.distances.truncate(matches.count);
+    return matches;
 }
 
 void Index::reserve(size_t capacity) const { index_->reserve(capacity); }
@@ -59,12 +65,15 @@ void Index::view(rust::Str path) const { index_->view(std::string(path).c_str())
 accuracy_t accuracy(rust::Str quant) { return accuracy_from_name(quant.data(), quant.size()); }
 
 std::unique_ptr<Index> wrap(punned_t&& index) {
-    std::shared_ptr<punned_t> native = std::make_shared<punned_t>(std::move(index));
-    return std::unique_ptr<Index>(new Index(native));
+    std::unique_ptr<punned_t> punned_ptr;
+    punned_ptr.reset(new punned_t(std::move(index)));
+    std::unique_ptr<Index> result;
+    result.reset(new Index(std::move(punned_ptr)));
+    return result;
 }
 
-config_t config(size_t connectivity, size_t exp_add, size_t exp_search) {
-    config_t result;
+index_config_t config(size_t connectivity, size_t exp_add, size_t exp_search) {
+    index_config_t result;
     result.connectivity = connectivity ? connectivity : default_connectivity();
     result.expansion_add = exp_add ? exp_add : default_expansion_add();
     result.expansion_search = exp_search ? exp_search : default_expansion_search();

package/rust/lib.hpp

@@ -17,7 +17,7 @@ class Index {
     using distance_t = unum::usearch::punned_distance_t;
     using punned_t = unum::usearch::punned_gt<label_t>;
 
-    Index(std::shared_ptr<punned_t> index);
+    Index(std::unique_ptr<punned_t> index);
 
     void reserve(size_t) const;
 
@@ -37,7 +37,7 @@ class Index {
     void view(rust::Str path) const;
 
   private:
-    std::shared_ptr<punned_t> index_;
+    std::unique_ptr<punned_t> index_;
 };
 
 std::unique_ptr<Index> new_ip(size_t dims, rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search);

package/setup.py

@@ -14,7 +14,7 @@ if sys.platform == 'linux':
     compile_args.append('-Wno-unknown-pragmas')
 
 if sys.platform == 'darwin':
-    # MacOS 10.15 orhigher is needed for `aligned_alloc` support.
+    # MacOS 10.15 or higher is needed for `aligned_alloc` support.
     # https://github.com/unum-cloud/usearch/actions/runs/4975434891/jobs/8902603392
     compile_args.append('-mmacosx-version-min=10.15')
     compile_args.append('-Wno-unknown-pragmas')
@@ -82,4 +82,7 @@ setup(
         'include', 'src',
         'fp16/include', 'robin-map/include', 'simsimd/include'],
     ext_modules=ext_modules,
+    extras_require={
+        'jit': ['numba'],
+    },
 )

package/src/CMakeLists.txt

@@ -12,6 +12,7 @@ endif()
 # List of all possible compiler IDs:
 # https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER_ID.html
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address")
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra -Wno-conversion -Wno-unknown-pragmas")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
@@ -20,11 +21,14 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
 
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address")
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wfatal-errors")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
 
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "NVIDIA" OR CMAKE_CXX_COMPILER_ID STREQUAL "NVHPC")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr --extended-lambda")
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -gencode arch=compute_86,code=sm_86")
     set_property(SOURCE bench.cpp PROPERTY LANGUAGE CUDA)
@@ -39,10 +43,6 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /DEBUG")
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2")
     set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /O2 /DEBUG")
-else()
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -pg -g")
 endif()
 
 if(APPLE)