Fix: Type casting warnings & free

Author: ashvardanian

include/stringzilla/stringzilla.h

@@ -6081,7 +6081,7 @@ SZ_PUBLIC void sz_fill_sve(sz_ptr_t target, sz_size_t length, sz_u8_t value) {
 
     if (length <= vec_len) {
         // Small buffer case: use mask to handle small writes
-        svbool_t mask = svwhilelt_b8(0ul, length);
+        svbool_t mask = svwhilelt_b8(0ull, length);
         svst1_u8(mask, (unsigned char *)target, value_vec);
     }
     else {
@@ -6091,7 +6091,7 @@ SZ_PUBLIC void sz_fill_sve(sz_ptr_t target, sz_size_t length, sz_u8_t value) {
         sz_size_t body_length = length - head_length - tail_length;
 
         // Handle unaligned head
-        svbool_t head_mask = svwhilelt_b8(0ul, head_length);
+        svbool_t head_mask = svwhilelt_b8(0ull, head_length);
         svst1_u8(head_mask, (unsigned char *)target, value_vec);
         target += head_length;
 
@@ -6101,7 +6101,7 @@ SZ_PUBLIC void sz_fill_sve(sz_ptr_t target, sz_size_t length, sz_u8_t value) {
         }
 
         // Handle unaligned tail
-        svbool_t tail_mask = svwhilelt_b8(0ul, tail_length);
+        svbool_t tail_mask = svwhilelt_b8(0ull, tail_length);
         svst1_u8(tail_mask, (unsigned char *)target, value_vec);
     }
 }
@@ -6118,7 +6118,7 @@ SZ_PUBLIC void sz_copy_sve(sz_ptr_t target, sz_cptr_t source, sz_size_t length)
     // When the buffer is small, there isn't much to innovate.
     if (length <= vec_len) {
         // Small buffer case: use mask to handle small writes
-        svbool_t mask = svwhilelt_b8(0ul, length);
+        svbool_t mask = svwhilelt_b8(0ull, length);
         svuint8_t data = svld1_u8(mask, (unsigned char *)source);
         svst1_u8(mask, (unsigned char *)target, data);
     }
@@ -6143,10 +6143,10 @@ SZ_PUBLIC void sz_copy_sve(sz_ptr_t target, sz_cptr_t source, sz_size_t length)
         sz_size_t body_length = length - head_length - tail_length;
 
         // Handle unaligned parts
-        svbool_t head_mask = svwhilelt_b8(0ul, head_length);
+        svbool_t head_mask = svwhilelt_b8(0ull, head_length);
         svuint8_t head_data = svld1_u8(head_mask, (unsigned char *)source);
         svst1_u8(head_mask, (unsigned char *)target, head_data);
-        svbool_t tail_mask = svwhilelt_b8(0ul, tail_length);
+        svbool_t tail_mask = svwhilelt_b8(0ull, tail_length);
         svuint8_t tail_data = svld1_u8(tail_mask, (unsigned char *)source + head_length + body_length);
         svst1_u8(tail_mask, (unsigned char *)target + head_length + body_length, tail_data);
         target += head_length;
@@ -6162,15 +6162,15 @@ SZ_PUBLIC void sz_copy_sve(sz_ptr_t target, sz_cptr_t source, sz_size_t length)
         // Up to (vec_len * 2 - 1) bytes of data may be left in the body,
         // so we can unroll the last two optional loop iterations.
         if (body_length > vec_len) {
-            svbool_t mask = svwhilelt_b8(0ul, body_length);
+            svbool_t mask = svwhilelt_b8(0ull, body_length);
             svuint8_t data = svld1_u8(mask, (unsigned char *)source);
             svst1_u8(mask, (unsigned char *)target, data);
             body_length -= vec_len;
             source += body_length;
             target += body_length;
         }
         if (body_length) {
-            svbool_t mask = svwhilelt_b8(0ul, body_length);
+            svbool_t mask = svwhilelt_b8(0ull, body_length);
             svuint8_t data = svld1_u8(mask, (unsigned char *)source);
             svst1_u8(mask, (unsigned char *)target, data);
         }

scripts/bench_memory.cpp

@@ -22,6 +22,24 @@
 using namespace ashvardanian::stringzilla::scripts;
 constexpr std::size_t max_shift_length = 299;
 
+/**
+ *  @brief  Wraps platform-specific @b aligned memory allocation and deallocation functions.
+ *          Compatible with `std::unique_ptr` as the second template argument, to free the memory.
+ */
+struct page_alloc_and_free_t {
+#ifdef _WIN32
+    inline char *operator()(std::size_t alignment, std::size_t size) const noexcept {
+        return reinterpret_cast<char *>(_aligned_malloc(size, alignment));
+    }
+    inline void operator()(char *ptr) const noexcept { _aligned_free(ptr); }
+#else
+    inline char *operator()(std::size_t alignment, std::size_t size) const noexcept {
+        return reinterpret_cast<char *>(std::aligned_alloc(alignment, size));
+    }
+    inline void operator()(char *ptr) const noexcept { std::free(ptr); }
+#endif
+};
+
 /**
  *  @brief  Benchmarks `memcpy`-like operations in 2 modes: aligned @b output buffer and unaligned.
  *
@@ -226,17 +244,10 @@ int main(int argc, char const **argv) {
     if (!SZ_DEBUG) seconds_per_benchmark *= 5;
 
     // Create an aligned buffer for the output
-    struct aligned_free_t {
-        inline void operator()(char *ptr) const noexcept { std::free(ptr); }
-    };
-    std::unique_ptr<char, aligned_free_t> output_buffer;
+    std::unique_ptr<char, page_alloc_and_free_t> output_buffer;
     // Add space for at least one cache line to simplify unaligned exports
     std::size_t const output_length = round_up_to_multiple<4096>(dataset.text.size() + max_shift_length);
-#ifdef _WIN32
-    output_buffer.reset(reinterpret_cast<char *>(_aligned_malloc(output_length, 4096)));
-#else
-    output_buffer.reset(reinterpret_cast<char *>(std::aligned_alloc(4096, output_length)));
-#endif
+    output_buffer.reset(page_alloc_and_free_t {}(4096, output_length));
     if (!output_buffer) {
         std::fprintf(stderr, "Failed to allocate an output buffer of %zu bytes.\n", output_length);
         return 1;

scripts/test.cpp

@@ -1447,16 +1447,16 @@ void test_replacements(std::size_t lookup_tables_to_try = 128, std::size_t slice
     for (std::size_t lookup_table_variation = 0; lookup_table_variation != lookup_tables_to_try;
          ++lookup_table_variation) {
         sz::look_up_table lut;
-        for (std::size_t i = 0; i < 256; i++) lut[i] = (char)(std::rand() % 256);
+        for (std::size_t i = 0; i < 256; i++) lut[(char)i] = (char)(std::rand() % 256);
 
         for (std::size_t slice_idx = 0; slice_idx != slices_per_table; ++slice_idx) {
-            std::size_t slice_offset = std::rand() % body.length();
+            std::size_t slice_offset = std::rand() % (body.length());
             std::size_t slice_length = std::rand() % (body.length() - slice_offset);
 
             sz::transform<char>(sz::string_view(body.data() + slice_offset, slice_length), lut,
                                 const_cast<char *>(transformed.data()) + slice_offset);
             for (std::size_t i = 0; i != slice_length; ++i) {
-                assert(transformed[slice_offset + i] == lut[(unsigned char)body[slice_offset + i]]);
+                assert(transformed[slice_offset + i] == lut[body[slice_offset + i]]);
             }
         }
     }