tommasobelluzzo/fasthashes

A .NET implementation of several non-cryptographic hashes.

🔧 Technologies

📈 GitHub Stats

🙏 Donation

If you found any of my projects useful to you, please consider making a donation to support its maintenance and development:

fasthashes's Issues

s_AllowsUnalignedRead causing inconsistent hash results in .NET 4.0

NOTE: This is probably a very niche problem since I needed to compile the source myself to get it to work with an existing .NET 4.0 project.

If the source code as is is used in .NET 4.0, I've encountered in my unit tests that the produced hash value alternates between different executions. Since it alternates between two values i suspect the problem has something to do with wrong memory alignment. This happens when compiling for "Any CPU" and executing on a 64bit OS.

Always setting the s_AllowsUnalignedRead flag in the Hash class to true seemed to fix this error. Am I correct in the understanding that if the s_AllowsUnalignedRead flag is set to true you allow less optimization?

For my application this change did not affect performance in any significant way so I might just keep it at that, but I would appreciate any insight you might have on this issue.

Best,
Elias

komihash 5

Please update komihash to v5. I would also like to inquire why komihash's benchmarked speed is low in your .NET implementation? I assume it's due to the use of 64x64 to 128 bit multiplication intrinsic which may not be available in .NET. Could you recheck the implementation? It's possible to use the __umulh intrinsic instead of _umul128, which is also fast.

There was a question about streamed implementation - komihash features a streamed implementation now.
https://github.com/avaneev/komihash

Several more hashes and benchmarks

Nice project!

I have several string hash benchmarks and tests here, if you're interested (Marvin, djb2, Fnv-1a, etc):
https://github.com/KirillOsenkov/Benchmarks/tree/main/src/Tests

Benchmark results here:
https://github.com/KirillOsenkov/Benchmarks/blob/516b5bde9bd7bdc59a9fdd5b6436b26480d7d795/src/Tests/StringHash.cs#L12-L25

FarmHash128 throws IndexOutOfRangeException when input size is exactly 16

If input length is exactly 16 bytes then FarmHash128.ComputeHash throws an IndexOutOfRangeException .

Expected Behavior

Function should work.

Current Behavior

Exception is thrown:

System.IndexOutOfRangeException: Index was outside the bounds of the array.
   at FastHashes.FarmHash128.Hash1To3(UInt64& hash1, UInt64& hash2, ReadOnlySpan`1 buffer, Int32 offset, Int32 count, UInt64 seed1, UInt64 seed2)
   at FastHashes.FarmHash128.ComputeHashInternal(ReadOnlySpan`1 buffer)
   at FastHashes.Hash.ComputeHash(Byte[] buffer, Int32 offset, Int32 count)
   at FastHashes.Hash.ComputeHash(Byte[] buffer)

Steps to Reproduce

byte[] input = new byte[16];
FarmHash128 fh = new FarmHash128();
fh.ComputeHash(input);

Note

An exception is also thrown when input size is 0.

Implementation of Stream Hashing

As far as I can see all hash functions expect an in-memory buffer.
I would like to compute hashes for very large files (way beyond RAM limits) that necessitate reading smaller chunks into memory and compute the hash in steps.
Is it at present possible with FastHash?

SpookyHash Version

Hello,
am wondering if your implementation of the SpookyHash is V2 or not. Thanks so much.