stringzillas-cuda 4.2.0__tar.gz → 4.2.2__tar.gz

{stringzillas_cuda-4.2.0/stringzillas_cuda.egg-info → stringzillas_cuda-4.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stringzillas-cuda
-Version: 4.2.0
+Version: 4.2.2
 Summary: Search, hash, sort, fingerprint, and fuzzy-match strings faster via SWAR, SIMD, and CUDA on Nvidia GPUs
 Home-page: https://github.com/ashvardanian/StringZilla
 Author: Ash Vardanian
@@ -30,7 +30,7 @@ Classifier: Topic :: Text Processing :: Indexing
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: stringzilla==4.2.0
+Requires-Dist: stringzilla==4.2.2
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -374,6 +374,7 @@ Consider contributing if you need a feature that's not yet implemented.
 | Character Set Search           |    🌳     |   ✅   |   ✅   |   ✅    |   ✅   |   ✅   |   ✅   |   ✅   |
 | Sorting & Sequence Operations  |    🌳     |   ✅   |   ✅   |   ✅    |   ✅   |   ⚪   |   ⚪   |   ⚪   |
 | Streaming Hashes               |    🌳     |   ✅   |   ✅   |   ✅    |   ✅   |   ✅   |   ✅   |   ✅   |
+| SHA-256 Checksums              |    🌳     |   ✅   |   ✅   |   ✅    |   ✅   |   ✅   |   ✅   |   ✅   |
 | Small String Class             |    🧐     |   ✅   |   ✅   |   ❌    |   ⚪   |   ❌   |   ❌   |   ❌   |
 | Lazy Ranges, Compressed Arrays |    🌳     |   ❌   |   ✅   |   ✅    |   ✅   |   ❌   |   ⚪   |   ⚪   |
 |                                |          |       |       |        |       |       |       |       |
@@ -507,6 +508,55 @@ streamed = hasher.digest() # or `hexdigest()` for a string
 assert one == streamed
 ```
 
+### SHA-256 Checksums
+
+SHA-256 cryptographic checksums are also available for single-shot and incremental hashing:
+
+```py
+import stringzilla as sz
+
+# One-shot SHA-256
+digest_bytes = sz.sha256(b"Hello, world!")
+assert len(digest_bytes) == 32
+
+# Incremental SHA-256
+hasher = sz.Sha256()
+hasher.update(b"Hello, ").update(b"world!")
+digest_bytes = hasher.digest()
+digest_hex = hasher.hexdigest()  # 64 character lowercase hex string
+
+# HMAC-SHA256 for message authentication
+mac = sz.hmac_sha256(key=b"secret", message=b"Hello, world!")
+```
+
+StringZilla integrates seamlessly with memory-mapped files for efficient large file processing.
+The traditional approach with `hashlib`:
+
+```python
+import hashlib
+
+with open("xlsum.csv", "rb") as streamed_file:
+    hasher = hashlib.sha256()
+    while chunk := streamed_file.read(4096):
+        hasher.update(chunk)
+    checksum = hasher.hexdigest()
+```
+
+Can be simplified with StringZilla:
+
+```python
+from stringzilla import Sha256, File
+
+mapped_file = File("xlsum.csv")
+checksum = Sha256().update(mapped_file).hexdigest()
+```
+
+Both output the same digest: `7278165ce01a4ac1e8806c97f32feae908036ca3d910f5177d2cf375e20aeae1`.
+OpenSSL (powering `hashlib`) has faster Assembly kernels, but StringZilla avoids file I/O overhead with memory mapping and skips Python's abstraction layers:
+
+- OpenSSL-backed `hashlib.sha256`: 12.6s
+- StringZilla end-to-end: 4.0s — __3× faster!__
+
 ### Collection-Level Operations
 
 Once split into a `Strs` object, you can sort, shuffle, and reorganize the slices with minimal memory footprint.
@@ -800,12 +850,19 @@ sz_u64_t hash = sz_hash(haystack.start, haystack.length, 42);    // 42 is the se
 sz_u64_t checksum = sz_bytesum(haystack.start, haystack.length); // or accumulate byte values
 
 // Hash strings incrementally with "init", "update", and "digest":
-sz_hash_state_t state; 
+sz_hash_state_t state;
 sz_hash_state_init(&state, 42);
 sz_hash_state_update(&state, haystack.start, 1);                        // first char
 sz_hash_state_update(&state, haystack.start + 1, haystack.length - 1);  // rest of the string
 sz_u64_t streamed_hash = sz_hash_state_digest(&state);
 
+// SHA-256 cryptographic checksums
+sz_u8_t digest[32];
+sz_sha256_state_t sha_state;
+sz_sha256_state_init(&sha_state);
+sz_sha256_state_update(&sha_state, haystack.start, haystack.length);
+sz_sha256_state_digest(&sha_state, digest);
+
 // Perform collection level operations
 sz_sequence_t array = {your_handle, your_count, your_get_start, your_get_length};
 sz_sequence_argsort(&array, &your_config);
@@ -1463,7 +1520,7 @@ __`SZ_DEBUG`__:
 > If you want to enable more aggressive bounds-checking, define `SZ_DEBUG` before including the header.
 > If not explicitly set, it will be inferred from the build type.
 
-__`SZ_USE_WESTMERE`, `SZ_USE_HASWELL`, `SZ_USE_SKYLAKE`, `SZ_USE_ICE`, `SZ_USE_NEON`, `SZ_USE_NEON_AES`, `SZ_USE_SVE`, `SZ_USE_SVE2`, `SZ_USE_SVE2_AES`__:
+__`SZ_USE_GOLDMONT`, `SZ_USE_WESTMERE`, `SZ_USE_HASWELL`, `SZ_USE_SKYLAKE`, `SZ_USE_ICE`, `SZ_USE_NEON`, `SZ_USE_NEON_AES`, `SZ_USE_NEON_SHA`, `SZ_USE_SVE`, `SZ_USE_SVE2`, `SZ_USE_SVE2_AES`__:
 
 > One can explicitly disable certain families of SIMD instructions for compatibility purposes.
 > Default values are inferred at compile time depending on compiler support (for dynamic dispatch) and the target architecture (for static dispatch).
@@ -1597,6 +1654,27 @@ map.insert("a", 1);
 assert_eq!(map.get("a"), Some(&1));
 ```
 
+### SHA-256 Checksums
+
+SHA-256 cryptographic checksums are available:
+
+```rs
+use stringzilla::sz;
+
+// One-shot SHA-256
+let digest = sz::Sha256::hash(b"Hello, world!");
+assert_eq!(digest.len(), 32);
+
+// Incremental SHA-256
+let mut hasher = sz::Sha256::new();
+hasher.update(b"Hello, ");
+hasher.update(b"world!");
+let digest = hasher.digest();
+
+// HMAC-SHA256 for message authentication
+let mac = sz::hmac_sha256(b"secret", b"Hello, world!");
+```
+
 ### Similarity Scores
 
 StringZilla exposes high-performance, batch-oriented similarity via the `szs` module.
@@ -1775,6 +1853,24 @@ const streamedHash = hasher.digest(); // returns BigInt
 console.assert(hash === streamedHash);
 ```
 
+### SHA-256 Checksums
+
+SHA-256 cryptographic checksums are available:
+
+```js
+import sz from 'stringzilla';
+
+// One-shot SHA-256
+const digest = sz.sha256(Buffer.from('Hello, world!')); // returns Buffer (32 bytes)
+
+// Incremental SHA-256
+const hasher = new sz.Sha256();
+hasher.update(Buffer.from('Hello, '));
+hasher.update(Buffer.from('world!'));
+const digestBuffer = hasher.digest();     // returns Buffer (32 bytes)
+const digestHex = hasher.hexdigest();     // returns string (64 hex chars)
+```
+
 ## Quick Start: Swift 🍏
 
 StringZilla can be added as a dependency in the Swift Package Manager.
@@ -1808,13 +1904,31 @@ import StringZilla
 let hash = "Hello, world!".hash(seed: 42)
 
 // Incremental hashing for streaming data
-var hasher = SZHasher(seed: 42)
+var hasher = StringZillaHasher(seed: 42)
 hasher.update("Hello, ")
 hasher.update("world!")
 let streamedHash = hasher.digest()
 assert(hash == streamedHash)
 ```
 
+### SHA-256 Checksums
+
+SHA-256 cryptographic checksums are available:
+
+```swift
+import StringZilla
+
+// One-shot SHA-256
+let digest = "Hello, world!".sha256() // returns [UInt8] (32 bytes)
+
+// Incremental SHA-256
+var hasher = StringZillaSha256Hasher()
+hasher.update("Hello, ")
+hasher.update("world!")
+let digestBytes = hasher.digest()     // [UInt8] (32 bytes)
+let digestHex = hasher.hexdigest()    // String (64 hex chars)
+```
+
 ## Quick Start: GoLang 🦫
 
 Add the Go binding as a module dependency:
@@ -1867,16 +1981,64 @@ func main() {
 
 ### Hash
 
-Single-shot and incremental hashing are both supported:
+Single-shot and incremental hashing are both supported.
+The `Hasher` type implements Go's standard `hash.Hash64` and `io.Writer` interfaces:
 
 ```go
+import (
+    "io"
+    sz "github.com/ashvardanian/stringzilla/golang"
+)
+
+// One-shot hashing
 one := sz.Hash("Hello, world!", 42)
 
+// Streaming hasher (implements hash.Hash64 and io.Writer)
 hasher := sz.NewHasher(42)
 hasher.Write([]byte("Hello, "))
 hasher.Write([]byte("world!"))
-streamed := hasher.Digest()
-fmt.Println(one == streamed) // true
+streamed := hasher.Digest()         // or hasher.Sum64()
+fmt.Println(one == streamed)        // true
+
+// Works with io.Copy and any io.Reader
+file, _ := os.Open("data.txt")
+hasher.Reset()
+io.Copy(hasher, file)
+fileHash := hasher.Sum64()
+```
+
+### SHA-256 Checksums
+
+SHA-256 cryptographic checksums are available.
+The `Sha256` type implements Go's standard `hash.Hash` and `io.Writer` interfaces:
+
+```go
+import (
+    "io"
+    sz "github.com/ashvardanian/stringzilla/golang"
+)
+
+// One-shot SHA-256
+digest := sz.HashSha256([]byte("Hello, world!"))
+fmt.Printf("%x\n", digest)          // prints 32-byte hash in hex
+
+// Streaming SHA-256 (implements hash.Hash and io.Writer)
+hasher := sz.NewSha256()
+hasher.Write([]byte("Hello, "))
+hasher.Write([]byte("world!"))
+digestBytes := hasher.Digest()      // [32]byte
+digestHex := hasher.Hexdigest()     // string (64 hex chars)
+
+// Works with io.Copy and any io.Reader
+file, _ := os.Open("data.bin")
+hasher.Reset()
+io.Copy(hasher, file)
+fileDigest := hasher.Digest()
+
+// Standard hash.Hash interface methods
+sum := hasher.Sum(nil)              // []byte with 32 bytes
+size := hasher.Size()               // 32
+blockSize := hasher.BlockSize()     // 64
 ```
 
 ## Algorithms & Design Decisions 📚
@@ -2173,6 +2335,11 @@ Also, unlike some alternatives, with "masked" AVX-512 and "predicated" SVE loads
 > § Reading materials.
 > [Stress-testing hash functions for avalance behaviour, collision bias, and distribution](https://github.com/ashvardanian/HashEvals).
 
+### SHA-256 Checksums
+
+In addition to the fast AES-based hash, StringZilla implements hardware-accelerated SHA-256 cryptographic checksums.
+The implementation follows the [FIPS 180-4 specification](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf) and provides multiple backends.
+
 ### Random Generation
 
 StringZilla implements a fast [Pseudorandom Number Generator][faq-prng] inspired by the "AES-CTR-128" algorithm, reusing the same AES primitives as the hash function.
@@ -2261,6 +2428,7 @@ If you are looking for more reading materials on this topic, consider the follow
 - [The Painful Pitfalls of C++ STL Strings](https://ashvardanian.com/posts/painful-strings/).
 - [Processing Strings 109x Faster than Nvidia on H100](https://ashvardanian.com/posts/stringwars-on-gpus/).
 - [How a String Library Beat OpenCV at Image Processing by 4x](https://ashvardanian.com/posts/image-processing-with-strings/).
+- [2x Faster Hashes on AWS Graviton: NEON → SVE2](https://ashvardanian.com/posts/aws-graviton-checksums-on-neon-vs-sve/).
 
 ## License 📜
 

{stringzillas_cuda-4.2.0 → stringzillas_cuda-4.2.2}/README.md

@@ -329,6 +329,7 @@ Consider contributing if you need a feature that's not yet implemented.
 | Character Set Search           |    🌳     |   ✅   |   ✅   |   ✅    |   ✅   |   ✅   |   ✅   |   ✅   |
 | Sorting & Sequence Operations  |    🌳     |   ✅   |   ✅   |   ✅    |   ✅   |   ⚪   |   ⚪   |   ⚪   |
 | Streaming Hashes               |    🌳     |   ✅   |   ✅   |   ✅    |   ✅   |   ✅   |   ✅   |   ✅   |
+| SHA-256 Checksums              |    🌳     |   ✅   |   ✅   |   ✅    |   ✅   |   ✅   |   ✅   |   ✅   |
 | Small String Class             |    🧐     |   ✅   |   ✅   |   ❌    |   ⚪   |   ❌   |   ❌   |   ❌   |
 | Lazy Ranges, Compressed Arrays |    🌳     |   ❌   |   ✅   |   ✅    |   ✅   |   ❌   |   ⚪   |   ⚪   |
 |                                |          |       |       |        |       |       |       |       |
@@ -462,6 +463,55 @@ streamed = hasher.digest() # or `hexdigest()` for a string
 assert one == streamed
 ```
 
+### SHA-256 Checksums
+
+SHA-256 cryptographic checksums are also available for single-shot and incremental hashing:
+
+```py
+import stringzilla as sz
+
+# One-shot SHA-256
+digest_bytes = sz.sha256(b"Hello, world!")
+assert len(digest_bytes) == 32
+
+# Incremental SHA-256
+hasher = sz.Sha256()
+hasher.update(b"Hello, ").update(b"world!")
+digest_bytes = hasher.digest()
+digest_hex = hasher.hexdigest()  # 64 character lowercase hex string
+
+# HMAC-SHA256 for message authentication
+mac = sz.hmac_sha256(key=b"secret", message=b"Hello, world!")
+```
+
+StringZilla integrates seamlessly with memory-mapped files for efficient large file processing.
+The traditional approach with `hashlib`:
+
+```python
+import hashlib
+
+with open("xlsum.csv", "rb") as streamed_file:
+    hasher = hashlib.sha256()
+    while chunk := streamed_file.read(4096):
+        hasher.update(chunk)
+    checksum = hasher.hexdigest()
+```
+
+Can be simplified with StringZilla:
+
+```python
+from stringzilla import Sha256, File
+
+mapped_file = File("xlsum.csv")
+checksum = Sha256().update(mapped_file).hexdigest()
+```
+
+Both output the same digest: `7278165ce01a4ac1e8806c97f32feae908036ca3d910f5177d2cf375e20aeae1`.
+OpenSSL (powering `hashlib`) has faster Assembly kernels, but StringZilla avoids file I/O overhead with memory mapping and skips Python's abstraction layers:
+
+- OpenSSL-backed `hashlib.sha256`: 12.6s
+- StringZilla end-to-end: 4.0s — __3× faster!__
+
 ### Collection-Level Operations
 
 Once split into a `Strs` object, you can sort, shuffle, and reorganize the slices with minimal memory footprint.
@@ -755,12 +805,19 @@ sz_u64_t hash = sz_hash(haystack.start, haystack.length, 42);    // 42 is the se
 sz_u64_t checksum = sz_bytesum(haystack.start, haystack.length); // or accumulate byte values
 
 // Hash strings incrementally with "init", "update", and "digest":
-sz_hash_state_t state; 
+sz_hash_state_t state;
 sz_hash_state_init(&state, 42);
 sz_hash_state_update(&state, haystack.start, 1);                        // first char
 sz_hash_state_update(&state, haystack.start + 1, haystack.length - 1);  // rest of the string
 sz_u64_t streamed_hash = sz_hash_state_digest(&state);
 
+// SHA-256 cryptographic checksums
+sz_u8_t digest[32];
+sz_sha256_state_t sha_state;
+sz_sha256_state_init(&sha_state);
+sz_sha256_state_update(&sha_state, haystack.start, haystack.length);
+sz_sha256_state_digest(&sha_state, digest);
+
 // Perform collection level operations
 sz_sequence_t array = {your_handle, your_count, your_get_start, your_get_length};
 sz_sequence_argsort(&array, &your_config);
@@ -1418,7 +1475,7 @@ __`SZ_DEBUG`__:
 > If you want to enable more aggressive bounds-checking, define `SZ_DEBUG` before including the header.
 > If not explicitly set, it will be inferred from the build type.
 
-__`SZ_USE_WESTMERE`, `SZ_USE_HASWELL`, `SZ_USE_SKYLAKE`, `SZ_USE_ICE`, `SZ_USE_NEON`, `SZ_USE_NEON_AES`, `SZ_USE_SVE`, `SZ_USE_SVE2`, `SZ_USE_SVE2_AES`__:
+__`SZ_USE_GOLDMONT`, `SZ_USE_WESTMERE`, `SZ_USE_HASWELL`, `SZ_USE_SKYLAKE`, `SZ_USE_ICE`, `SZ_USE_NEON`, `SZ_USE_NEON_AES`, `SZ_USE_NEON_SHA`, `SZ_USE_SVE`, `SZ_USE_SVE2`, `SZ_USE_SVE2_AES`__:
 
 > One can explicitly disable certain families of SIMD instructions for compatibility purposes.
 > Default values are inferred at compile time depending on compiler support (for dynamic dispatch) and the target architecture (for static dispatch).
@@ -1552,6 +1609,27 @@ map.insert("a", 1);
 assert_eq!(map.get("a"), Some(&1));
 ```
 
+### SHA-256 Checksums
+
+SHA-256 cryptographic checksums are available:
+
+```rs
+use stringzilla::sz;
+
+// One-shot SHA-256
+let digest = sz::Sha256::hash(b"Hello, world!");
+assert_eq!(digest.len(), 32);
+
+// Incremental SHA-256
+let mut hasher = sz::Sha256::new();
+hasher.update(b"Hello, ");
+hasher.update(b"world!");
+let digest = hasher.digest();
+
+// HMAC-SHA256 for message authentication
+let mac = sz::hmac_sha256(b"secret", b"Hello, world!");
+```
+
 ### Similarity Scores
 
 StringZilla exposes high-performance, batch-oriented similarity via the `szs` module.
@@ -1730,6 +1808,24 @@ const streamedHash = hasher.digest(); // returns BigInt
 console.assert(hash === streamedHash);
 ```
 
+### SHA-256 Checksums
+
+SHA-256 cryptographic checksums are available:
+
+```js
+import sz from 'stringzilla';
+
+// One-shot SHA-256
+const digest = sz.sha256(Buffer.from('Hello, world!')); // returns Buffer (32 bytes)
+
+// Incremental SHA-256
+const hasher = new sz.Sha256();
+hasher.update(Buffer.from('Hello, '));
+hasher.update(Buffer.from('world!'));
+const digestBuffer = hasher.digest();     // returns Buffer (32 bytes)
+const digestHex = hasher.hexdigest();     // returns string (64 hex chars)
+```
+
 ## Quick Start: Swift 🍏
 
 StringZilla can be added as a dependency in the Swift Package Manager.
@@ -1763,13 +1859,31 @@ import StringZilla
 let hash = "Hello, world!".hash(seed: 42)
 
 // Incremental hashing for streaming data
-var hasher = SZHasher(seed: 42)
+var hasher = StringZillaHasher(seed: 42)
 hasher.update("Hello, ")
 hasher.update("world!")
 let streamedHash = hasher.digest()
 assert(hash == streamedHash)
 ```
 
+### SHA-256 Checksums
+
+SHA-256 cryptographic checksums are available:
+
+```swift
+import StringZilla
+
+// One-shot SHA-256
+let digest = "Hello, world!".sha256() // returns [UInt8] (32 bytes)
+
+// Incremental SHA-256
+var hasher = StringZillaSha256Hasher()
+hasher.update("Hello, ")
+hasher.update("world!")
+let digestBytes = hasher.digest()     // [UInt8] (32 bytes)
+let digestHex = hasher.hexdigest()    // String (64 hex chars)
+```
+
 ## Quick Start: GoLang 🦫
 
 Add the Go binding as a module dependency:
@@ -1822,16 +1936,64 @@ func main() {
 
 ### Hash
 
-Single-shot and incremental hashing are both supported:
+Single-shot and incremental hashing are both supported.
+The `Hasher` type implements Go's standard `hash.Hash64` and `io.Writer` interfaces:
 
 ```go
+import (
+    "io"
+    sz "github.com/ashvardanian/stringzilla/golang"
+)
+
+// One-shot hashing
 one := sz.Hash("Hello, world!", 42)
 
+// Streaming hasher (implements hash.Hash64 and io.Writer)
 hasher := sz.NewHasher(42)
 hasher.Write([]byte("Hello, "))
 hasher.Write([]byte("world!"))
-streamed := hasher.Digest()
-fmt.Println(one == streamed) // true
+streamed := hasher.Digest()         // or hasher.Sum64()
+fmt.Println(one == streamed)        // true
+
+// Works with io.Copy and any io.Reader
+file, _ := os.Open("data.txt")
+hasher.Reset()
+io.Copy(hasher, file)
+fileHash := hasher.Sum64()
+```
+
+### SHA-256 Checksums
+
+SHA-256 cryptographic checksums are available.
+The `Sha256` type implements Go's standard `hash.Hash` and `io.Writer` interfaces:
+
+```go
+import (
+    "io"
+    sz "github.com/ashvardanian/stringzilla/golang"
+)
+
+// One-shot SHA-256
+digest := sz.HashSha256([]byte("Hello, world!"))
+fmt.Printf("%x\n", digest)          // prints 32-byte hash in hex
+
+// Streaming SHA-256 (implements hash.Hash and io.Writer)
+hasher := sz.NewSha256()
+hasher.Write([]byte("Hello, "))
+hasher.Write([]byte("world!"))
+digestBytes := hasher.Digest()      // [32]byte
+digestHex := hasher.Hexdigest()     // string (64 hex chars)
+
+// Works with io.Copy and any io.Reader
+file, _ := os.Open("data.bin")
+hasher.Reset()
+io.Copy(hasher, file)
+fileDigest := hasher.Digest()
+
+// Standard hash.Hash interface methods
+sum := hasher.Sum(nil)              // []byte with 32 bytes
+size := hasher.Size()               // 32
+blockSize := hasher.BlockSize()     // 64
 ```
 
 ## Algorithms & Design Decisions 📚
@@ -2128,6 +2290,11 @@ Also, unlike some alternatives, with "masked" AVX-512 and "predicated" SVE loads
 > § Reading materials.
 > [Stress-testing hash functions for avalance behaviour, collision bias, and distribution](https://github.com/ashvardanian/HashEvals).
 
+### SHA-256 Checksums
+
+In addition to the fast AES-based hash, StringZilla implements hardware-accelerated SHA-256 cryptographic checksums.
+The implementation follows the [FIPS 180-4 specification](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf) and provides multiple backends.
+
 ### Random Generation
 
 StringZilla implements a fast [Pseudorandom Number Generator][faq-prng] inspired by the "AES-CTR-128" algorithm, reusing the same AES primitives as the hash function.
@@ -2216,6 +2383,7 @@ If you are looking for more reading materials on this topic, consider the follow
 - [The Painful Pitfalls of C++ STL Strings](https://ashvardanian.com/posts/painful-strings/).
 - [Processing Strings 109x Faster than Nvidia on H100](https://ashvardanian.com/posts/stringwars-on-gpus/).
 - [How a String Library Beat OpenCV at Image Processing by 4x](https://ashvardanian.com/posts/image-processing-with-strings/).
+- [2x Faster Hashes on AWS Graviton: NEON → SVE2](https://ashvardanian.com/posts/aws-graviton-checksums-on-neon-vs-sve/).
 
 ## License 📜
 

stringzillas_cuda-4.2.2/VERSION

@@ -0,0 +1 @@
+4.2.2

{stringzillas_cuda-4.2.0 → stringzillas_cuda-4.2.2}/c/stringzilla.c

@@ -20,17 +20,10 @@
 #include <stringzilla/stringzilla.h>
 
 #if SZ_AVOID_LIBC
-// If we don't have the LibC, the `malloc` definition in `stringzilla.h` will be illformed.
 #ifdef _MSC_VER
 typedef sz_size_t size_t; // Reuse the type definition we've inferred from `stringzilla.h`
-extern __declspec(dllimport) int rand(void);
-extern __declspec(dllimport) void free(void *start);
-extern __declspec(dllimport) void *malloc(size_t length);
 #else
 typedef __SIZE_TYPE__ size_t; // For GCC/Clang
-extern int rand(void);
-extern void free(void *start);
-extern void *malloc(size_t length);
 #endif
 #endif
 
@@ -128,6 +121,14 @@ static void sz_dispatch_table_update_implementation_(sz_capability_t caps) {
     }
 #endif
 
+#if SZ_USE_GOLDMONT
+    if (caps & sz_cap_goldmont_k) {
+        impl->sha256_state_init = sz_sha256_state_init_goldmont;
+        impl->sha256_state_update = sz_sha256_state_update_goldmont;
+        impl->sha256_state_digest = sz_sha256_state_digest_goldmont;
+    }
+#endif
+
 #if SZ_USE_HASWELL
     if (caps & sz_cap_haswell_k) {
         impl->equal = sz_equal_haswell;
@@ -189,6 +190,10 @@ static void sz_dispatch_table_update_implementation_(sz_capability_t caps) {
         impl->hash_state_digest = sz_hash_state_digest_ice;
         impl->fill_random = sz_fill_random_ice;
 
+        impl->sha256_state_init = sz_sha256_state_init_ice;
+        impl->sha256_state_update = sz_sha256_state_update_ice;
+        impl->sha256_state_digest = sz_sha256_state_digest_ice;
+
         impl->sequence_intersect = sz_sequence_intersect_ice;
     }
 #endif
@@ -239,7 +244,8 @@ static void sz_dispatch_table_update_implementation_(sz_capability_t caps) {
         impl->copy = sz_copy_sve;
         impl->move = sz_move_sve;
         impl->fill = sz_fill_sve;
-
+        impl->lookup = sz_lookup_sve;
+	
         impl->find = sz_find_sve;
         // TODO: impl->rfind = sz_rfind_sve;
         impl->find_byte = sz_find_byte_sve;

{stringzillas_cuda-4.2.0 → stringzillas_cuda-4.2.2}/c/stringzillas.cuh

@@ -910,6 +910,7 @@ SZ_DYNAMIC sz_status_t sz_memory_allocator_init_unified(sz_memory_allocator_t *a
     alloc->handle = nullptr;
     return propagate_error(sz::status_t::success_k, error_message);
 #else
+    sz_unused_(alloc); // Suppress unused parameter warning when CUDA is not used
     return propagate_error(sz::status_t::missing_gpu_k, error_message);
 #endif
 }
@@ -1073,6 +1074,8 @@ SZ_DYNAMIC sz_status_t szs_levenshtein_distances_init(
     sz_memory_allocator_t const *alloc, sz_capability_t capabilities,                              //
     szs_levenshtein_distances_t *engine_punned, char const **error_message) {
 
+    sz_unused_(alloc); // Custom allocator not yet implemented, using default
+    sz_unused_(capabilities); // Optional backends may be compiled out
     sz_assert_(engine_punned != nullptr && *engine_punned == nullptr && "Engine must be uninitialized");
 
     // If the gap opening and extension costs are identical we can use less memory
@@ -1253,6 +1256,7 @@ SZ_DYNAMIC sz_status_t szs_levenshtein_distances_utf8_init(
     sz_memory_allocator_t const *alloc, sz_capability_t capabilities,                              //
     szs_levenshtein_distances_utf8_t *engine_punned, char const **error_message) {
 
+    sz_unused_(alloc); // Custom allocator not yet implemented, using default
     sz_assert_(engine_punned != nullptr && *engine_punned == nullptr && "Engine must be uninitialized");
 
     // If the gap opening and extension costs are identical we can use less memory
@@ -1357,6 +1361,8 @@ SZ_DYNAMIC sz_status_t szs_needleman_wunsch_scores_init(                       /
     sz_memory_allocator_t const *alloc, sz_capability_t capabilities,          //
     szs_needleman_wunsch_scores_t *engine_punned, char const **error_message) {
 
+    sz_unused_(alloc); // Custom allocator not yet implemented, using default
+    sz_unused_(capabilities); // Optional backends may be compiled out
     sz_assert_(engine_punned != nullptr && *engine_punned == nullptr && "Engine must be uninitialized");
 
     // If the gap opening and extension costs are identical we can use less memory
@@ -1511,6 +1517,8 @@ SZ_DYNAMIC sz_status_t szs_smith_waterman_scores_init(                         /
     sz_memory_allocator_t const *alloc, sz_capability_t capabilities,          //
     szs_smith_waterman_scores_t *engine_punned, char const **error_message) {
 
+    sz_unused_(alloc); // Custom allocator not yet implemented, using default
+    sz_unused_(capabilities); // Optional backends may be compiled out
     sz_assert_(engine_punned != nullptr && *engine_punned == nullptr && "Engine must be uninitialized");
 
     // If the gap opening and extension costs are identical we can use less memory
@@ -1666,6 +1674,8 @@ SZ_DYNAMIC sz_status_t szs_fingerprints_init(                         //
     sz_memory_allocator_t const *alloc, sz_capability_t capabilities, //
     szs_fingerprints_t *engine_punned, char const **error_message) {
 
+    sz_unused_(alloc); // Custom allocator not yet implemented, using default
+    sz_unused_(capabilities); // Optional backends may be compiled out
     sz_assert_(engine_punned != nullptr && *engine_punned == nullptr && "Engine must be uninitialized");
 
     // Use some default window widths if none are provided

{stringzillas_cuda-4.2.0 → stringzillas_cuda-4.2.2}/include/stringzilla/compare.h

@@ -432,10 +432,10 @@ SZ_PUBLIC sz_bool_t sz_equal_skylake(sz_cptr_t a, sz_cptr_t b, sz_size_t length)
 #pragma region NEON Implementation
 #if SZ_USE_NEON
 #if defined(__clang__)
-#pragma clang attribute push(__attribute__((target("arch=armv8.2-a+simd"))), apply_to = function)
+#pragma clang attribute push(__attribute__((target("+simd"))), apply_to = function)
 #elif defined(__GNUC__)
 #pragma GCC push_options
-#pragma GCC target("arch=armv8.2-a+simd")
+#pragma GCC target("+simd")
 #endif
 
 SZ_PUBLIC sz_ordering_t sz_order_neon(sz_cptr_t a, sz_size_t a_length, sz_cptr_t b, sz_size_t b_length) {
@@ -479,10 +479,10 @@ SZ_PUBLIC sz_bool_t sz_equal_neon(sz_cptr_t a, sz_cptr_t b, sz_size_t length) {
 #pragma region SVE Implementation
 #if SZ_USE_SVE
 #if defined(__clang__)
-#pragma clang attribute push(__attribute__((target("arch=armv8.2-a+sve"))), apply_to = function)
+#pragma clang attribute push(__attribute__((target("+sve"))), apply_to = function)
 #elif defined(__GNUC__)
 #pragma GCC push_options
-#pragma GCC target("arch=armv8.2-a+sve")
+#pragma GCC target("+sve")
 #endif
 
 SZ_PUBLIC sz_bool_t sz_equal_sve(sz_cptr_t a, sz_cptr_t b, sz_size_t length) {