react-native-update 10.53.1 → 10.55.0

package/android/jni/HDiffPatch/test/testHashClash.cpp

@@ -1,436 +0,0 @@
-// testHashClash.cpp
-// tool for HDiff
-// An estimation method for detecting hash clashs
-/*
- The MIT License (MIT)
- Copyright (c) 2012-2019 HouSisong
- 
- Permission is hereby granted, free of charge, to any person
- obtaining a copy of this software and associated documentation
- files (the "Software"), to deal in the Software without
- restriction, including without limitation the rights to use,
- copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the
- Software is furnished to do so, subject to the following
- conditions:
- 
- The above copyright notice and this permission notice shall be
- included in all copies of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include <iostream>
-#include <stdlib.h>
-#include <vector>
-#include <unordered_map>
-#include "zlib.h"
-#include "md5.h" // https://sourceforge.net/projects/libmd5-rfc
-#include "../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
-#include "../_clock_for_demo.h"
-typedef unsigned char   TByte;
-typedef ptrdiff_t       TInt;
-typedef size_t          TUInt;
-
-/*
-struct THash{
-    typename TValue;
-    static const char* name() const;
-    void hash_begin();
-    void hash(const TByte* pdata,const TByte* pdataEnd);
-    void hash_finish(TValue* hv);
-};*/
-
-struct THash_md5_128{
-    typedef std::pair<uint64_t,uint64_t> TValue;
-    inline static const char* name() { return "md5_128"; }
-    md5_state_t _hv;
-    inline void hash_begin() { md5_init(&_hv); }
-    inline void hash(const TByte* pdata,const TByte* pdata_end)
-        { md5_append(&_hv,pdata,(int)(pdata_end-pdata)); }
-    inline void hash_end(TValue* hv) { md5_finish(&_hv,(TByte*)hv); }
-};
-
-namespace std{
-    template<> struct hash<THash_md5_128::TValue>{
-        inline size_t operator()(const THash_md5_128::TValue& v) const{
-            return v.first^v.second; }
-    };
-    template<> struct less<THash_md5_128::TValue>{
-        inline bool operator()(const THash_md5_128::TValue& x,const THash_md5_128::TValue& y)const{
-            return (x.first^x.second) < (y.first^y.second); }
-    };
-}
-
-struct THash_crc32{
-    typedef uint32_t TValue;
-    inline static const char* name() { return "crc32"; }
-    TValue _hv;
-    inline void hash_begin() { _hv=(TValue)crc32(0,0,0); }
-    inline void hash(const TByte* pdata,const TByte* pdata_end)
-                        { _hv=(TValue)crc32(_hv,pdata,(uInt)(pdata_end-pdata)); }
-    inline void hash_end(TValue* hv) { *hv=_hv; }
-};
-
-struct THash_adler32{
-    typedef uint32_t TValue;
-    inline static const char* name() { return "adler32"; }
-    TValue _hv;
-    inline void hash_begin() { _hv=(TValue)adler32(0,0,0); }
-    inline void hash(const TByte* pdata,const TByte* pdata_end)
-                        { _hv=(TValue)adler32(_hv,pdata,(uInt)(pdata_end-pdata)); }
-    inline void hash_end(TValue* hv) { *hv=_hv; }
-};
-
-
-struct THash_adler32h{
-    typedef uint32_t TValue;
-    inline static const char* name() { return "adler32h"; }
-    TValue _hv;
-    inline void hash_begin() { _hv=adler32_start(0,0); }
-    inline void hash(const TByte* pdata,const TByte* pdata_end)
-                        { _hv=adler32_append(_hv,pdata,(pdata_end-pdata));
-                            //assert(_hv==(TValue)adler32(1,pdata,(pdata_end-pdata)));
-                        }
-    inline void hash_end(TValue* hv) { *hv=_hv; }
-};
-
-struct THash_fadler32{
-    typedef uint32_t TValue;
-    inline static const char* name() { return "fadler32"; }
-    TValue _hv;
-    inline void hash_begin() { _hv=fast_adler32_start(0,0); }
-    inline void hash(const TByte* pdata,const TByte* pdata_end)
-                    { _hv=fast_adler32_append(_hv,pdata,(pdata_end-pdata)); }
-    inline void hash_end(TValue* hv) { *hv=_hv; }
-};
-
-struct THash_adler64h{
-    typedef uint64_t TValue;
-    inline static const char* name() { return "adler64h"; }
-    TValue _hv;
-    inline void hash_begin() { _hv=adler64_start(0,0); }
-    inline void hash(const TByte* pdata,const TByte* pdata_end)
-                    { _hv=adler64_append(_hv,pdata,(pdata_end-pdata)); }
-    inline void hash_end(TValue* hv) { *hv=_hv; }
-};
-
-struct THash_fadler64{
-    typedef uint64_t TValue;
-    inline static const char* name() { return "fadler64"; }
-    TValue _hv;
-    inline void hash_begin() { _hv=fast_adler64_start(0,0); }
-    inline void hash(const TByte* pdata,const TByte* pdata_end)
-                    { _hv=fast_adler64_append(_hv,pdata,(pdata_end-pdata)); }
-    inline void hash_end(TValue* hv) { *hv=_hv; }
-};
-
-struct THash_fadler128{
-    typedef adler128_t TValue;
-    inline static const char* name() { return "fadler128"; }
-    TValue _hv;
-    inline void hash_begin() { _hv=fast_adler128_start(0,0); }
-    inline void hash(const TByte* pdata,const TByte* pdata_end)
-                    { _hv=fast_adler128_append(_hv,pdata,(pdata_end-pdata)); }
-    inline void hash_end(TValue* hv) { *hv=_hv; }
-};
-struct _adler128_t_hash{
-    inline size_t operator()(const adler128_t& c)const{
-        return c.adler ^ c.sum;
-    }
-};
-struct _adler128_t_cmp{
-    inline bool operator()(const adler128_t& x, const adler128_t& y)const{
-        return (x.adler==y.adler) & (x.sum==y.sum);
-    }
-};
-
-const uint64_t kMaxMapNodeSize=80000000ull; //run test memory ctrl
-const size_t   kRandTestMaxSize=1024*1024*1024;//test rand data size
-const size_t   kMaxHashDataSize=256;
-      size_t   kMinClash=0; //run test max time ctrl
-
-template <class THash,class TUInt,int kTestBit=sizeof(TUInt)*8,TUInt kTestMask=(TUInt)~(TUInt)0>
-void test(const TByte* data,const TByte* data_end){
-    typedef typename THash::TValue                TValue;
-    typedef std::pair<const TByte*,const TByte*>  TPair;
-    typedef std::unordered_map<TUInt,TPair> TMap;
-    double time0=clock_s();
-    const size_t clip_count=sizeof(TValue)/sizeof(TUInt);
-    assert(clip_count*sizeof(TUInt)==sizeof(TValue)); //unsupport other bit
-    TMap maps[clip_count];
-    for (size_t m=0;m<clip_count;++m)
-        maps[m].reserve(kMaxMapNodeSize*3/clip_count);
-    unsigned int rand_seed=7;
-    if (kTestMask!=(TUInt)~(TUInt)0) printf("mask[%08X %08X] ",(int)(kTestMask>>32),(int)kTestMask);
-    printf("%s%s ",THash::name(),std::string(10-strlen(THash::name()),' ').c_str());
-    
-    uint64_t    curClashMin=0;
-    uint64_t    clashs[clip_count]={0};
-    double clashBases[clip_count]={0};
-    size_t i=0;
-    while (curClashMin<kMinClash) {
-        uint64_t    clashMin=-(uint64_t)1;
-        for (size_t m=0;m<clip_count;++m){
-            if (clashs[m]<clashMin) clashMin=clashs[m];
-        }
-        curClashMin=clashMin;
-        
-        size_t dlen=rand_r(&rand_seed) % kMaxHashDataSize;
-        size_t dstrat=rand_r(&rand_seed) % ((data_end-data) - dlen);
-        assert(dstrat+dlen<=(data_end-data));
-        const TByte* pv    =data+dstrat;
-        const TByte* pv_end=pv+dlen;
-        
-        THash th;
-        typename THash::TValue hvs;
-        th.hash_begin();
-        th.hash(pv,pv_end);
-        th.hash_end(&hvs);
-        for (size_t m=0;m<clip_count;++m){
-            TMap&     map=maps[m];
-            uint64_t& clash=clashs[m];
-            double& clashBase=clashBases[m];
-            TUInt hv=((TUInt*)&hvs)[m];
-            hv&=kTestMask;
-            auto it=map.find(hv);
-            if (it==map.end()){
-                if (map.size()*clip_count<kMaxMapNodeSize)
-                    map[hv]=TPair(pv,pv_end);
-                clashBase+=map.size();
-                ++i;
-            }else{
-                const TPair& v=it->second;
-                const TByte* vf=v.first;
-                if ((pv_end-pv)!=(v.second-vf)){
-                    ++clash;
-                    clashBase+=map.size();
-                    ++i;
-                } else if (pv==vf){
-                    //same i
-                }else{
-                    bool isEq=true;
-                    for (size_t e=0; e<dlen; ++e) {
-                        if (pv[e]==vf[e]){
-                            continue;
-                        }else{
-                            isEq=false;
-                            break;
-                        }
-                    }
-                    if (isEq){
-                        //same i
-                    }else{
-                        ++clash;
-                        clashBase+=map.size();
-                        ++i;
-                    }
-                }
-            }
-        }
-    }
-    for (size_t m=0;m<clip_count;++m)
-        maps[m].clear();
-    
-    printf("test %dbitx%d, clash rate: ",kTestBit,(int)clip_count);
-    if (clip_count>0) printf("[");
-    for (size_t m=0;m<clip_count; ++m) {
-        double clashR=clashs[m]/clashBases[m];
-        if (m>0) printf(" ");
-        if (clashR>0){
-            //printf("%.3e(%.1fbit)",clashR,log2(1/clashR));
-            printf("%.2fbit",log2(1/clashR));
-        }else{
-            printf("0/%.3e",clashBases[m]);
-        }
-    }
-    if (clip_count>0) printf("]");
-    printf(" \ttime:%.1fs\n",(clock_s()-time0));
-}
-
-template <uint64_t kTestMask0,uint64_t kTestMask1>
-void test_fadler128(const TByte* data,const TByte* data_end){
-    typedef THash_fadler128 THash;
-    typedef uint64_t TUInt;
-    typedef typename THash::TValue                TValue;
-    typedef std::pair<const TByte*,const TByte*>  TPair;
-    typedef std::unordered_map<TValue,TPair,_adler128_t_hash,_adler128_t_cmp> TMap;
-    double time0=clock_s();
-    const size_t clip_count=1;
-    TMap maps[clip_count];
-    for (size_t m=0;m<clip_count;++m)
-        maps[m].reserve(kMaxMapNodeSize*3/clip_count);
-    unsigned int rand_seed=7;
-    printf("mask[%08X %08X ",(int)(kTestMask1>>32),(int)kTestMask1);
-    printf("%08X %08X] ",(int)(kTestMask0>>32),(int)kTestMask0);
-    printf("%s%s ",THash::name(),std::string(10-strlen(THash::name()),' ').c_str());
-    
-    uint64_t    curClashMin=0;
-    uint64_t    clashs[clip_count]={0};
-    double clashBases[clip_count]={0};
-    size_t i=0;
-    while (curClashMin<kMinClash) {
-        uint64_t    clashMin=-(uint64_t)1;
-        for (size_t m=0;m<clip_count;++m){
-            if (clashs[m]<clashMin) clashMin=clashs[m];
-        }
-        curClashMin=clashMin;
-        
-        size_t dlen=rand_r(&rand_seed) % kMaxHashDataSize;
-        size_t dstrat=rand_r(&rand_seed) % ((data_end-data) - dlen);
-        assert(dstrat+dlen<=(data_end-data));
-        const TByte* pv    =data+dstrat;
-        const TByte* pv_end=pv+dlen;
-        
-        THash th;
-        typename THash::TValue hvs;
-        th.hash_begin();
-        th.hash(pv,pv_end);
-        th.hash_end(&hvs);
-        for (size_t m=0;m<clip_count;++m){
-            TMap&     map=maps[m];
-            uint64_t& clash=clashs[m];
-            double& clashBase=clashBases[m];
-            TValue hv=hvs;
-            hv.adler&=kTestMask0;
-            hv.sum&=kTestMask1;
-            auto it=map.find(hv);
-            if (it==map.end()){
-                if (map.size()*clip_count<kMaxMapNodeSize)
-                    map[hv]=TPair(pv,pv_end);
-                clashBase+=map.size();
-                ++i;
-            }else{
-                const TPair& v=it->second;
-                const TByte* vf=v.first;
-                if ((pv_end-pv)!=(v.second-vf)){
-                    ++clash;
-                    clashBase+=map.size();
-                    ++i;
-                } else if (pv==vf){
-                    //same i
-                }else{
-                    bool isEq=true;
-                    for (size_t e=0; e<dlen; ++e) {
-                        if (pv[e]==vf[e]){
-                            continue;
-                        }else{
-                            isEq=false;
-                            break;
-                        }
-                    }
-                    if (isEq){
-                        //same i
-                    }else{
-                        ++clash;
-                        clashBase+=map.size();
-                        ++i;
-                    }
-                }
-            }
-        }
-    }
-    for (size_t m=0;m<clip_count;++m)
-        maps[m].clear();
-    
-    printf("clash rate: ");
-    if (clip_count>0) printf("[");
-    for (size_t m=0;m<clip_count; ++m) {
-        double clashR=clashs[m]/clashBases[m];
-        if (m>0) printf(" ");
-        if (clashR>0){
-            //printf("%.3e(%.1fbit)",clashR,log2(1/clashR));
-            printf("%.2fbit",log2(1/clashR));
-        }else{
-            printf("0/%.3e",clashBases[m]);
-        }
-    }
-    if (clip_count>0) printf("]");
-    printf(" \ttime:%.1fs\n",(clock_s()-time0));
-}
-
-int main() {
-    double bestCR_32bit =1.0/(((uint64_t)1)<<32);
-    double bestCR_64bit =bestCR_32bit*bestCR_32bit;
-    double bestCR_128bit=bestCR_64bit*bestCR_64bit;
-    printf("32bit  hash  best clash rate: %.3e (1/%llu) \n",
-           bestCR_32bit,(((uint64_t)1)<<32));
-    printf("48bit  hash  best clash rate: %.3e (1/%llu) \n",
-           1.0/(((uint64_t)1)<<48),(((uint64_t)1)<<48));
-    printf("64bit  hash  best clash rate: %.3e (1/%llu%llu) \n",
-           bestCR_64bit,(((uint64_t)(-(uint64_t)1)))/10,(((uint64_t)(-(uint64_t)1)))%10+1);
-    printf("128bit hash  best clash rate: %.3e (1/%.3e) \n\n",
-           bestCR_128bit,1/bestCR_128bit);
-    
-    std::vector<TByte> data(kRandTestMaxSize);
-    unsigned int rand_seed=0;
-    for (size_t i=0; i<data.size(); ++i) {
-        data[i]=(TByte)rand_r(&rand_seed);
-    }
-    const uint64_t kTestMask8=((((uint64_t)1)<<8)-1);
-    const uint64_t kTestMask16=((((uint64_t)1)<<16)-1);
-    const uint64_t kTestMask32=((((uint64_t)1)<<32)-1);
-    const uint64_t kTestMask64=~(uint64_t)0;
-    
-    //*
-    kMinClash=100000;
-    test<THash_adler32,uint8_t>(data.data(),data.data()+data.size());
-    test<THash_adler32,uint16_t>(data.data(),data.data()+data.size());
-    test<THash_adler32,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler32h,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_crc32,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_md5_128,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler64h,uint8_t>(data.data(),data.data()+data.size());
-    test<THash_adler64h,uint16_t>(data.data(),data.data()+data.size());
-    test<THash_adler64h,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_adler64h,uint64_t>(data.data(),data.data()+data.size());
-    test<THash_fadler32,uint8_t>(data.data(),data.data()+data.size());
-    test<THash_fadler32,uint16_t>(data.data(),data.data()+data.size());
-    test<THash_fadler32,uint32_t>(data.data(),data.data()+data.size());
-    test<THash_fadler64,uint8_t>(data.data(),data.data()+data.size());
-    test<THash_fadler64,uint16_t>(data.data(),data.data()+data.size());
-    test<THash_fadler64,uint32_t>(data.data(),data.data()+data.size());
-    //test<THash_fadler64,uint64_t>(data.data(),data.data()+data.size());
-    test<THash_fadler128,uint8_t>(data.data(),data.data()+data.size());
-    test<THash_fadler128,uint16_t>(data.data(),data.data()+data.size());
-    test<THash_fadler128,uint32_t>(data.data(),data.data()+data.size());
-    kMinClash=50;
-    test<THash_fadler128,uint64_t>(data.data(),data.data()+data.size());
-    printf("\n");
-    //*/
-    //*
-     printf("NOTE: test fadler64 32bit ...\n");
-    kMinClash=100000;
-    test<THash_fadler64,uint64_t,32,kTestMask32>(data.data(),data.data()+data.size());
-    test<THash_fadler64,uint64_t,32,kTestMask32<<32>(data.data(),data.data()+data.size());
-    test<THash_fadler64,uint64_t,32,kTestMask32<<16>(data.data(),data.data()+data.size());
-    test<THash_fadler64,uint64_t,32,kTestMask16|kTestMask16<<32>(data.data(),data.data()+data.size());
-    test<THash_fadler64,uint64_t,32,kTestMask16<<16|kTestMask16<<48>(data.data(),data.data()+data.size());
-    test<THash_fadler64,uint64_t,32,kTestMask16|kTestMask16<<48>(data.data(),data.data()+data.size());
-    printf("\n");
-    //*/
-    /*
-    printf("NOTE: not enough time to get next test results ...\n");
-    kMinClash=1;
-    test_fadler128<kTestMask32,kTestMask32>(data.data(),data.data()+data.size());
-    test_fadler128<kTestMask32,kTestMask32<<32>(data.data(),data.data()+data.size());
-    test_fadler128<kTestMask32<<32,kTestMask32>(data.data(),data.data()+data.size());
-    test_fadler128<kTestMask32<<32,kTestMask32<<32>(data.data(),data.data()+data.size());
-    printf("\n");
-    //*/
-    //*
-    printf("NOTE: not enough time to get next test results ...\n");
-    kMinClash=1; // for timesaving but increase deviation
-    test<THash_fadler64,uint64_t>(data.data(),data.data()+data.size());
-    test<THash_md5_128,uint64_t>(data.data(),data.data()+data.size());
-    //*/
-    return 0;
-}
-