xxhash.h
Go to the documentation of this file.
00001 /*
00002    xxHash - Fast Hash algorithm
00003    Header File
00004    Copyright (C) 2012-2014, Yann Collet.
00005    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
00006 
00007    Redistribution and use in source and binary forms, with or without
00008    modification, are permitted provided that the following conditions are
00009    met:
00010   
00011        * Redistributions of source code must retain the above copyright
00012    notice, this list of conditions and the following disclaimer.
00013        * Redistributions in binary form must reproduce the above
00014    copyright notice, this list of conditions and the following disclaimer
00015    in the documentation and/or other materials provided with the
00016    distribution.
00017   
00018    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00019    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00020    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00021    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00022    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00023    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00024    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00025    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00026    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00027    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00028    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00029 
00030    You can contact the author at :
00031    - xxHash source repository : http://code.google.com/p/xxhash/
00032 */
00033 
00034 /* Notice extracted from xxHash homepage :
00035 
00036 xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
00037 It also successfully passes all tests from the SMHasher suite.
00038 
00039 Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
00040 
00041 Name            Speed       Q.Score   Author
00042 xxHash          5.4 GB/s     10
00043 CrapWow         3.2 GB/s      2       Andrew
00044 MumurHash 3a    2.7 GB/s     10       Austin Appleby
00045 SpookyHash      2.0 GB/s     10       Bob Jenkins
00046 SBox            1.4 GB/s      9       Bret Mulvey
00047 Lookup3         1.2 GB/s      9       Bob Jenkins
00048 SuperFastHash   1.2 GB/s      1       Paul Hsieh
00049 CityHash64      1.05 GB/s    10       Pike & Alakuijala
00050 FNV             0.55 GB/s     5       Fowler, Noll, Vo
00051 CRC32           0.43 GB/s     9
00052 MD5-32          0.33 GB/s    10       Ronald L. Rivest
00053 SHA1-32         0.28 GB/s    10
00054 
00055 Q.Score is a measure of quality of the hash function. 
00056 It depends on successfully passing SMHasher test set. 
00057 10 is a perfect score.
00058 */
00059 
00060 #pragma once
00061 
00062 #if defined (__cplusplus)
00063 extern "C" {
00064 #endif
00065 
00066 
00067 //****************************
00068 // Type
00069 //****************************
00070 typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
00071 
00072 
00073 
00074 //****************************
00075 // Simple Hash Functions
00076 //****************************
00077 
00078 unsigned int XXH32 (const void* input, int len, unsigned int seed);
00079 
00080 /*
00081 XXH32() :
00082     Calculate the 32-bits hash of sequence of length "len" stored at memory address "input".
00083     The memory between input & input+len must be valid (allocated and read-accessible).
00084     "seed" can be used to alter the result predictably.
00085     This function successfully passes all SMHasher tests.
00086     Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
00087     Note that "len" is type "int", which means it is limited to 2^31-1.
00088     If your data is larger, use the advanced functions below.
00089 */
00090 
00091 
00092 
00093 //****************************
00094 // Advanced Hash Functions
00095 //****************************
00096 
00097 void*         XXH32_init   (unsigned int seed);
00098 XXH_errorcode XXH32_update (void* state, const void* input, int len);
00099 unsigned int  XXH32_digest (void* state);
00100 
00101 /*
00102 These functions calculate the xxhash of an input provided in several small packets,
00103 as opposed to an input provided as a single block.
00104 
00105 It must be started with :
00106 void* XXH32_init()
00107 The function returns a pointer which holds the state of calculation.
00108 
00109 This pointer must be provided as "void* state" parameter for XXH32_update().
00110 XXH32_update() can be called as many times as necessary.
00111 The user must provide a valid (allocated) input.
00112 The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
00113 Note that "len" is type "int", which means it is limited to 2^31-1. 
00114 If your data is larger, it is recommended to chunk your data into blocks 
00115 of size for example 2^30 (1GB) to avoid any "int" overflow issue.
00116 
00117 Finally, you can end the calculation anytime, by using XXH32_digest().
00118 This function returns the final 32-bits hash.
00119 You must provide the same "void* state" parameter created by XXH32_init().
00120 Memory will be freed by XXH32_digest().
00121 */
00122 
00123 
00124 int           XXH32_sizeofState();
00125 XXH_errorcode XXH32_resetState(void* state, unsigned int seed);
00126 
00127 #define       XXH32_SIZEOFSTATE 48
00128 typedef struct { long long ll[(XXH32_SIZEOFSTATE+(sizeof(long long)-1))/sizeof(long long)]; } XXH32_stateSpace_t;
00129 /*
00130 These functions allow user application to make its own allocation for state.
00131 
00132 XXH32_sizeofState() is used to know how much space must be allocated for the xxHash 32-bits state.
00133 Note that the state must be aligned to access 'long long' fields. Memory must be allocated and referenced by a pointer.
00134 This pointer must then be provided as 'state' into XXH32_resetState(), which initializes the state.
00135 
00136 For static allocation purposes (such as allocation on stack, or freestanding systems without malloc()),
00137 use the structure XXH32_stateSpace_t, which will ensure that memory space is large enough and correctly aligned to access 'long long' fields.
00138 */
00139 
00140 
00141 unsigned int XXH32_intermediateDigest (void* state);
00142 /*
00143 This function does the same as XXH32_digest(), generating a 32-bit hash,
00144 but preserve memory context.
00145 This way, it becomes possible to generate intermediate hashes, and then continue feeding data with XXH32_update().
00146 To free memory context, use XXH32_digest(), or free().
00147 */
00148 
00149 
00150 
00151 //****************************
00152 // Deprecated function names
00153 //****************************
00154 // The following translations are provided to ease code transition
00155 // You are encouraged to no longer this function names
00156 #define XXH32_feed   XXH32_update
00157 #define XXH32_result XXH32_digest
00158 #define XXH32_getIntermediateResult XXH32_intermediateDigest
00159 
00160 
00161 
00162 #if defined (__cplusplus)
00163 }
00164 #endif


roslz4
Author(s): Ben Charrow
autogenerated on Thu Jun 6 2019 21:09:51