අද්විතීයභාවය සහ වේගය සඳහා වඩාත් සුදුසු වන්නේ කුමන හැෂිං ඇල්ගොරිතමද? උදාහරණ (හොඳ) භාවිතයට හැෂ් ශබ්ද කෝෂ ඇතුළත් වේ.

SHA-256 වැනි දේ ඇති බව මම දනිමි , නමුත් මෙම ඇල්ගොරිතම ආරක්ෂිතව නිර්මාණය කර ඇති අතර , එයින් අදහස් කරන්නේ ඒවා අද්විතීය නොවන ඇල්ගොරිතමයන්ට වඩා මන්දගාමී බවයි . මට අවශ්‍ය වන්නේ හැෂ් ඇල්ගොරිතමයක් වේගවත් ලෙස නිර්මාණය කර ඇති නමුත් ගැටුම් වළක්වා ගැනීම සඳහා තරමක් අද්විතීයව සිටීමයි.

මම වෙනස් ඇල්ගොරිතම කිහිපයක් පරීක්ෂා කළෙමි, වේගය සහ ගැටුම් ගණන මැනීම.

මම වෙනස් යතුරු කට්ටල තුනක් භාවිතා කළෙමි:

• ඉංග්‍රීසි වචන ^216,553 ක ලැයිස්තුවක් ^{🕗 සංරක්ෂිතය} (කුඩා අකුරින්)
• සංඛ්යා "1"සඳහා "216553"(හිතන්නේ ZIP කේත, සහ ආකාරය දුප්පත් හැෂ් msn.com පහතට ගෙන ^{🕗 සංරක්ෂිත} )
• 216,553 “අහඹු” (එනම් 4 වර්ගයේ uuid ) GUIDs

එක් එක් මළකඳ සඳහා, isions ට්ටන ගණන සහ හැෂිං සඳහා ගත කළ සාමාන්‍ය කාලය සටහන් විය.

මම පරීක්ෂා කළා:

• DJB2
• DJB2a ( xorවඩා භාවිතා කරන ප්‍රභේදය +)
• FNV-1 (32-බිට්)
• FNV-1a (32-බිට්)
• SDBM
• CRC32
• මැසිවිලි 2 (32-බිට්)
• සුපර් ෆාස්ට් හැෂ්

ප්රතිපල

සෑම ප්‍රති result ලයක්ම සාමාන්‍ය හැෂ් කාලය සහ isions ට්ටන ගණන අඩංගු වේ

Hash           Lowercase      Random UUID  Numbers
=============  =============  ===========  ==============
Murmur            145 ns      259 ns          92 ns
                    6 collis    5 collis       0 collis
FNV-1a            152 ns      504 ns          86 ns
                    4 collis    4 collis       0 collis
FNV-1             184 ns      730 ns          92 ns
                    1 collis    5 collis       0 collis▪
DBJ2a             158 ns      443 ns          91 ns
                    5 collis    6 collis       0 collis▪▪▪
DJB2              156 ns      437 ns          93 ns
                    7 collis    6 collis       0 collis▪▪▪
SDBM              148 ns      484 ns          90 ns
                    4 collis    6 collis       0 collis**
SuperFastHash     164 ns      344 ns         118 ns
                   85 collis    4 collis   18742 collis
CRC32             250 ns      946 ns         130 ns
                    2 collis    0 collis       0 collis
LoseLose          338 ns        -             -
               215178 collis

සටහන් :

• මෙම LoseLose ඇල්ගොරිතමය (එහිදී එහි පූරක = හැෂ් + චරිතය) යනු සත්ය භයංකර . සෑම දෙයක්ම එකම බාල්දි 1,375 කට ගැටේ
• සුපර් ෆාස්ට් හැෂ් වේගවත් ය. මගේ යහපත්කම නිසා සංඛ්‍යා .ට්ටනය. මම බලාපොරොත්තු වෙනවා එය වරාය කළ තැනැත්තාට යම් වැරැද්දක් වෙයි කියලා; ඒක ගොඩක් නරකයි
• CRC32 සෑහෙන්න හොඳයි . මන්දගාමී, සහ 1k බැලීමේ මේසයක්

Isions ට්ටන ඇත්ත වශයෙන්ම සිදු වේද?

ඔව්. හැෂ් isions ට්ටන ඇත්ත වශයෙන්ම සිදුවන්නේ දැයි බැලීමට මම මගේ පරීක්ෂණ වැඩසටහන ලිවීමට පටන් ගතිමි - එය හුදෙක් න්‍යායාත්මක ඉදිකිරීමක් නොවේ. ඒවා ඇත්ත වශයෙන්ම සිදු වේ:

FNV-1 isions ට්ටන

• creamwove සමඟ ගැටේ quists

FNV-1a isions ට්ටන

• costarring සමඟ ගැටේ liquid
• declinate සමඟ ගැටේ macallums
• altarage සමඟ ගැටේ zinke
• altarages සමඟ ගැටේ zinkes

මැසිවිලි 2 ගැටීම

• cataract සමඟ ගැටේ periti
• roquette සමඟ ගැටේ skivie
• shawl සමඟ ගැටේ stormbound
• dowlases සමඟ ගැටේ tramontane
• cricketings සමඟ ගැටේ twanger
• longans සමඟ ගැටේ whigs

DJB2 isions ට්ටන

• hetairas සමඟ ගැටේ mentioner
• heliotropes සමඟ ගැටේ neurospora
• depravement සමඟ ගැටේ serafins
• stylist සමඟ ගැටේ subgenera
• joyful සමඟ ගැටේ synaphea
• redescribed සමඟ ගැටේ urites
• dram සමඟ ගැටේ vivency

DJB2a isions ට්ටන

• haggadot සමඟ ගැටේ loathsomenesses
• adorablenesses සමඟ ගැටේ rentability
• playwright සමඟ ගැටේ snush
• playwrighting සමඟ ගැටේ snushing
• treponematoses සමඟ ගැටේ waterbeds

CRC32 isions ට්ටන

• codding සමඟ ගැටේ gnu
• exhibiters සමඟ ගැටේ schlager

සුපර් ෆාස්ට් හැෂ් isions ට්ටන

• dahabiah සමඟ ගැටේ drapability
• encharm සමඟ ගැටේ enclave
• grahams සමඟ ගැටේ gramary
• ... ගැටුම් 79 ක් ගිල දමන්න ...
• night සමඟ ගැටේ vigil
• nights සමඟ ගැටේ vigils
• finks සමඟ ගැටේ vinic

සසම්භාවීකරණය

අනෙක් විෂයානුබද්ධ මිනුම වන්නේ හෑෂ් අහඹු ලෙස බෙදා හරින ආකාරයයි. එහි ප්‍රති ing ලයක් ලෙස හැෂ් ටේබල් සිතියම්ගත කිරීමෙන් දත්ත කෙතරම් ඒකාකාරව බෙදා හරිනවාද යන්න පෙන්වයි. රේඛාව රේඛීයව සිතියම්ගත කිරීමේදී සියලුම හැෂ් කාර්යයන් හොඳ බෙදාහැරීමක් පෙන්නුම් කරයි:

හෝ හිල්බට් සිතියමක් ලෙස ( XKCD සැමවිටම අදාළ වේ ):

අංකය නූල් hashing විට (හැර "1", "2", ..., "216553") (උදාහරණයක් ලෙස, ZIP කේත ), රටා hashing දක්නට නොමැත්තේ ඉතා මතු වීමට පටන් එහිදී:

SDBM :

DJB2a :

FNV-1 :

FNV-1a හැර අන් සියල්ලම මට තවමත් අහඹු ලෙස පෙනේ:

ඇත්ත වශයෙන්ම, මැසිවිලි 2Numbers ට වඩා හොඳ අහඹු බවක් ඇති බව පෙනේ FNV-1a:

මම දකින විට FNV-1a"අංකය" සිතියම, මම හිතන්නේ මම සියුම් සිරස් රටාවන් බලන්න. මැසිවිලි නඟන විට මට කිසිදු රටාවක් නොපෙනේ. ඔයා සිතන්නේ කුමක් ද?

*වගුවේ ඇති අමතර දේ අහඹු බව කෙතරම් නරකද යන්න දක්වයි. සමග FNV-1aහොඳම වීම, සහ DJB2xනරකම වීම:

      Murmur2: .
       FNV-1a: .
        FNV-1: ▪
         DJB2: ▪▪
        DJB2a: ▪▪
         SDBM: ▪▪▪
SuperFastHash: .
          CRC: ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
     Loselose: ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
                                        ▪
                                 ▪▪▪▪▪▪▪▪▪▪▪▪▪
                        ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
          ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪

මම මුලින් මෙම වැඩසටහන ලිව්වේ ගැටුම් ගැන කරදර විය යුතුද යන්න තීරණය කිරීම සඳහා ය : මම එසේ කරමි.

ඉන්පසු එය හැෂ් ශ්‍රිත ප්‍රමාණවත් තරම් අහඹු ලෙස සිදු වන බවට වග බලා ගත්තේය.

FNV-1a ඇල්ගොරිතම

FNV1 හැෂ් 32, 64, 128, 256, 512 සහ 1024 බිට් හැෂ් ආපසු ලබා දෙන ප්‍රභේදයන්ගෙන් පැමිණේ.

මෙම FNV-1 අ ඇල්ගොරිතමය වේ:

hash = FNV_offset_basis
for each octetOfData to be hashed
    hash = hash xor octetOfData
    hash = hash * FNV_prime
return hash

නියතයන් FNV_offset_basisසහ FNV_primeඔබට අවශ්‍ය ආපසු හැෂ් ප්‍රමාණය මත රඳා පවතින තැන:

Hash Size  
===========
32-bit
    prime: 2^24 + 2^8 + 0x93 = 16777619
    offset: 2166136261
64-bit
    prime: 2^40 + 2^8 + 0xb3 = 1099511628211
    offset: 14695981039346656037
128-bit
    prime: 2^88 + 2^8 + 0x3b = 309485009821345068724781371
    offset: 144066263297769815596495629667062367629
256-bit
    prime: 2^168 + 2^8 + 0x63 = 374144419156711147060143317175368453031918731002211
    offset: 100029257958052580907070968620625704837092796014241193945225284501741471925557
512-bit
    prime: 2^344 + 2^8 + 0x57 = 35835915874844867368919076489095108449946327955754392558399825615420669938882575126094039892345713852759
    offset: 9659303129496669498009435400716310466090418745672637896108374329434462657994582932197716438449813051892206539805784495328239340083876191928701583869517785
1024-bit
    prime: 2^680 + 2^8 + 0x8d = 5016456510113118655434598811035278955030765345404790744303017523831112055108147451509157692220295382716162651878526895249385292291816524375083746691371804094271873160484737966720260389217684476157468082573
    offset: 1419779506494762106872207064140321832088062279544193396087847491461758272325229673230371772250864096521202355549365628174669108571814760471015076148029755969804077320157692458563003215304957150157403644460363550505412711285966361610267868082893823963790439336411086884584107735010676915

වැඩි විස්තර සඳහා ප්‍රධාන FNV පිටුව බලන්න.

මගේ සියලු ප්‍රති results ල බිට් 32 ප්‍රභේදය සමඟ ඇත.

FNV-1a FNV-1a ට වඩා හොඳද?

FNV-1a වටේට වඩා හොඳයි. කෝපස් යන ඉංග්‍රීසි වචනය භාවිතා කරන විට FNV-1a සමඟ වැඩි ගැටුම් ඇති විය:

Hash    Word Collisions
======  ===============
FNV-1   1
FNV-1a  4

දැන් කුඩා අකුරු සහ ලොකු අකුරු සංසන්දනය කරන්න:

Hash    lowercase word Collisions  UPPERCASE word collisions
======  =========================  =========================
FNV-1   1                          9
FNV-1a  4                          11

මෙම අවස්ථාවේ දී FNV-1a FN-1 ට වඩා "400%" නරක නැත , 20% ක් පමණක් නරක ය.

මම හිතන්නේ වඩා වැදගත් ගමනක් වන්නේ isions ට්ටන සම්බන්ධයෙන් ඇල්ගොරිතම පන්ති දෙකක් තිබීමයි:

• isions ට්ටන දුර්ලභ ය : FNV-1, FNV-1a, DJB2, DJB2a, SDBM
• isions ට්ටන පොදු : සුපර් ෆාස්ට් හැෂ්, ලොසෙලෝස්

එවිට හැෂ් කෙතරම් ඒකාකාරව බෙදා හරිනු ඇත්ද:

• කැපී පෙනෙන බෙදාහැරීම: මැසිවිලි 2, එෆ්එන්වී -1 ඒ, සුපර් ෆාස්ට්හස්
• විශිෂ්ට බෙදාහැරීම: FNV-1
• හොඳ බෙදාහැරීම: SDBM, DJB2, DJB2a
• භයානක බෙදාහැරීම: නැතිවීම

යාවත්කාලීන කරන්න

මැසිවිලි නඟනවාද? මොකද නැත්තේ අනිවාර්යෙන්ම

යාවත්කාලීන කරන්න

CRC32 ක්‍රියා කරන්නේ කෙසේදැයි ithshisname කල්පනා කර, මේසයට අංක එකතු කළේය.

CRC32 සෑහෙන්න හොඳයි . Isions ට්ටන ස්වල්පයක්, නමුත් මන්දගාමී වන අතර 1k බැලීමේ වගුවකට ඉහළින්.

CRC බෙදා හැරීම පිළිබඳ සියලු වැරදි දේ ඉවත් කරන්න - මගේ නරක

අද වන තුරු මම මගේ තථ්‍ය හැෂ්-මේස හැෂිං ඇල්ගොරිතම ලෙස FNV-1a භාවිතා කිරීමට ගියෙමි . නමුත් දැන් මම මැසිවිලි 2 වෙත මාරු වෙමි:

• ඉක්මනින්
• සියලුම පංති ආදාන වඩා හොඳ අහඹු ලෙස සකස් කිරීම

මට ඇත්තටම, ඇත්තටම සමග තියෙනවා යමක් වැරදි බලාපොරොත්තු වෙනවා SuperFastHashමට සොයා ඇල්ගොරිතමය ; එය තරම් ජනප්‍රිය වීම නරක ය.

යාවත්කාලීන කිරීම: සිට ගූගල් මත MurmurHash3 මුල්පිටුව :

(1) - සුපර් ෆාස්ට් හැෂ් ඉතා දුර්වල ision ට්ටන ගුණ ඇති අතර ඒවා වෙනත් තැනක ලේඛනගත කර ඇත.

ඒ නිසා මම හිතන්නේ එය මා පමණක් නොවේ.

යාවත්කාලීන කිරීම:Murmur අනෙක් ඒවාට වඩා වේගවත් වන්නේ මන්දැයි මම තේරුම් ගතිමි . MurmurHash2 වරකට බයිට් හතරක් මත ක්‍රියාත්මක වේ. බොහෝ ඇල්ගොරිතම බයිට් බයිට් වේ :

for each octet in Key
   AddTheOctetToTheHash

මෙයින් අදහස් කරන්නේ යතුරු වැඩි වන විට මැසිවිලි නඟන්නට අවස්ථාව ලැබෙන බවයි.

යාවත්කාලීන කරන්න

GUIDs නිර්මාණය කර ඇත්තේ අහඹු ලෙස නොව අද්විතීය ලෙසය

රේමන්ඩ් චෙන් විසින් කරන ලද කාලෝචිත සටහනක් මගින් අවධාරණය කරනුයේ “අහඹු” GUIDs ඒවායේ අහඹු බව සඳහා භාවිතා කිරීමට අදහස් නොකරන බවයි. ඒවා හෝ ඒවායේ උප කුලකයක් හැෂ් යතුරක් ලෙස නුසුදුසු ය:

4 වන අනුවාදය GUID ඇල්ගොරිතම පවා අනපේක්ෂිත යැයි සහතික නොවේ, මන්ද ඇල්ගොරිතම සසම්භාවී සංඛ්‍යා උත්පාදක යන්ත්‍රයේ ගුණාත්මකභාවය නියම නොකරයි. GUID සඳහා වන විකිපීඩියා ලිපියේ මූලික පර්යේෂණ අඩංගු වන අතර එයින් ඇඟවෙන්නේ අහඹු සංඛ්‍යා උත්පාදක තත්ත්වය පිළිබඳ දැනුම මත පදනම්ව අනාගත සහ පෙර GUIDs පුරෝකථනය කළ හැකි බැවින් උත්පාදක යන්ත්රය ගුප්ත විද්‍යාත්මකව ශක්තිමත් නොවන බවයි.

අහඹු ලෙස ගැටීම වැළැක්වීම හා සමාන නොවේ; “අහඹු” මාර්ගෝපදේශයක යම් උපකොටසක් ගැනීමෙන් ඔබේම “හැෂිං” ඇල්ගොරිතම නිර්මාණය කිරීමට උත්සාහ කිරීම වැරැද්දක් වන්නේ එබැවිනි.

int HashKeyFromGuid(Guid type4uuid)
{
   //A "4" is put somewhere in the GUID.
   //I can't remember exactly where, but it doesn't matter for
   //the illustrative purposes of this pseudocode
   int guidVersion = ((type4uuid.D3 & 0x0f00) >> 8);
   Assert(guidVersion == 4);

   return (int)GetFirstFourBytesOfGuid(type4uuid);
}

සටහන : නැවතත්, මම "අහඹු GUID" උපුටා දැක්වීම් වලට දැමුවෙමි, මන්ද එය GUID වල "අහඹු" ප්‍රභේදයයි. වඩාත් නිවැරදි විස්තරයක් වනු ඇත Type 4 UUID. නමුත් 4 වන වර්ගය හෝ 1, 3 සහ 5 වර්ග මොනවාදැයි කිසිවෙකු දන්නේ නැත. එබැවින් ඒවා "අහඹු" GUID ලෙස හැඳින්වීම පහසුය.

සියලුම ඉංග්‍රීසි වචන දර්පණ

• https://web.archive.org/web/20070221060514/http://www.sitopreferito.it/html/all_english_words.html
• https://drive.google.com/file/d/0B3BLwu7Vb2U-dEw1VkUxc3U4SG8/view?usp=sharing

වෙනස් නොවන ශබ්දකෝෂයකින් හැෂ් සිතියමක් නිර්මාණය කිරීමට ඔබට අවශ්‍ය නම්, පරිපූර්ණ හැෂිං https://en.wikipedia.org/wiki/Perfect_hash_function - හැෂ් ශ්‍රිතය සහ හැෂ් වගුව තැනීමේදී ඔබට සහතික විය හැකිය, දී ඇති දත්ත කට්ටලයක් සඳහා, isions ට්ටන සිදු නොවන බව.

මෙන්න හැෂ් ශ්‍රිත ලැයිස්තුවක්, නමුත් කෙටි අනුවාදය:

ඔබට හොඳ හැෂ් ශ්‍රිතයක් ලබා ගැනීමට අවශ්‍ය නම් සහ බලා සිටීමට නොහැකි නම්, djb2මම දන්නා හොඳම නූල් හැෂ් ශ්‍රිතයකි. විවිධ යතුරු කට්ටල සහ මේස ප්‍රමාණ මත එය විශිෂ්ට බෙදාහැරීමක් සහ වේගයක් ඇත

unsigned long
hash(unsigned char *str)
{
    unsigned long hash = 5381;
    int c;

    while (c = *str++)
        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */

    return hash;
}

ගූගල් හි සිටි හැෂ් යනු ඔබ සොයන ඇල්ගොරිතමයයි. ගුප්ත ලේඛනකරණය සඳහා එය හොඳ නොවන නමුත් අද්විතීය හැෂ් ජනනය කිරීම සඳහා හොඳය.

වැඩි විස්තර සඳහා බ්ලොගය කියවන්න සහ කේතය මෙහි ඇත.

CityHash C ++ හි ලියා ඇත. ද පවතී සරල සී වරාය .

32-බිට් සහාය:

සියලුම CityHash කාර්යයන් බිට් 64 ප්‍රොසෙසර සඳහා සුසර කර ඇත. එයින් කියැවෙන්නේ ඒවා බිට් 32 කේතයකින් (SSE4.2 භාවිතා කරන නව ඒවා හැර) ක්‍රියාත්මක වන බවයි. ඔවුන් ඉතා වේගවත් නොවනු ඇත. ඔබට මැසිවිලි හෝ වෙනත් දෙයක් 32-බිට් කේතයෙන් භාවිතා කිරීමට අවශ්‍ය විය හැකිය.

ලිපිගොනු හෑෂ් කිරීමේදී විවිධ හැෂිං ඇල්ගොරිතම කෙටි සංසන්දනයක් කිරීමට මම සැලසුම් කර ඇත්තෙමි.

තනි බිම් කොටස් කියවීමේ ක්‍රමයට වඩා සුළු වශයෙන් වෙනස් වන අතර මෙහි නොසලකා හැරිය හැක, මන්ද සියලුම ලිපිගොනු tmpfs තුළ ගබඩා කර ඇත. එබැවින් ඔබ පුදුම වන්නේ නම් මිණුම් ලකුණ IO- බැඳී නැත.

• රේඛීය පරිමාණය
• ල ar ු ගණක පරිමාණය

ඇල්ගොරිතම වලට ඇතුළත් වන්නේ : SpookyHash, CityHash, Murmur3, MD5, SHA{1,256,512}.

නිගමන:

• මර්මූර් 3, සිටිහාෂ් සහ ස්පූකි වැනි ගුප්ත-නොවන හැෂ් කාර්යයන් එකිනෙකට සමීපව පිහිටා ඇත. CRCමගේ CPU සතුව නොමැති SSE 4.2s උපදෙස් සහිත Cityhash CPU වල වේගවත් විය හැකි බව යමෙක් සටහන් කළ යුතුය . ස්පූකි හැෂ් සෑම විටම සිටි හැෂ් වලට පෙර ඉතා කුඩා විය.
• MD5 SHA256 තව තවත් තහවුරු විය හැක නමුත්, ගුප්ත ෙල්ඛන හැෂ් කාර්යයන් භාවිතා කරන විට හොඳ tradeoff බව පෙනේ ගැටීමෙන් අවදානම් තත්ත්ව තුළ MD5 හා SHA1 ය.
• සියලුම ඇල්ගොරිතම වල සංකීර්ණත්වය රේඛීය වේ - ඒවා අවහිරයකින් ක්‍රියා කරන බැවින් එය පුදුමයක් නොවේ. (කියවීමේ ක්‍රමයේ වෙනසක් තිබේදැයි බැලීමට මට අවශ්‍ය විය, එබැවින් ඔබට නිවැරදි අගයන් සංසන්දනය කළ හැකිය).
• SHA256 SHA512 ට වඩා මන්දගාමී විය.
• හැෂ් ක්‍රියාකාරිත්වයේ අහඹු බව මම විමර්ශනය කළේ නැත. නමුත් ඉයන් බොයිඩ්ස් පිළිතුරේ නැති හැෂ් ශ්‍රිත පිළිබඳ හොඳ සංසන්දනයක් මෙන්න . මෙයින් පෙන්වා දෙන්නේ CityHash හි කෙළවරේ යම් යම් ගැටළු ඇති බවයි.

බිම් කොටස් සඳහා භාවිතා කරන ප්‍රභවය:

• https://github.com/sahib/rmlint/tree/gh-pages/plots (කැත කේතය ගැන කණගාටුයි)

SHA ඇල්ගොරිතම (SHA-256 ඇතුළුව) වේගවත් ලෙස නිර්මාණය කර ඇත .

ඇත්ත වශයෙන්ම, ඔවුන්ගේ වේගය සමහර විට ගැටලුවක් විය හැකිය. විශේෂයෙන්, මුරපදයෙන් ලබාගත් ටෝකනයක් ගබඩා කිරීම සඳහා පොදු ක්‍රමයක් වන්නේ සම්මත වේගවත් හැෂ් ඇල්ගොරිතමයක් 10,000 වතාවක් ධාවනය කිරීමයි (මුරපදයේ හැෂ් හි හැෂ් හි හැෂ් ගබඩා කිරීම ... මුරපදය).

#!/usr/bin/env ruby
require 'securerandom'
require 'digest'
require 'benchmark'

def run_random_digest(digest, count)
  v = SecureRandom.random_bytes(digest.block_length)
  count.times { v = digest.digest(v) }
  v
end

Benchmark.bmbm do |x|
  x.report { run_random_digest(Digest::SHA256.new, 1_000_000) }
end

ප්‍රතිදානය:

Rehearsal ------------------------------------
   1.480000   0.000000   1.480000 (  1.391229)
--------------------------- total: 1.480000sec

       user     system      total        real
   1.400000   0.000000   1.400000 (  1.382016)

SHA-256 වැනි දේ ඇති බව මම දනිමි, නමුත් මෙම ඇල්ගොරිතම ආරක්ෂිතව නිර්මාණය කර ඇති අතර , එයින් අදහස් කරන්නේ ඒවා අඩු අද්විතීය ඇල්ගොරිතමයන්ට වඩා මන්දගාමී බවයි .

ගුප්ත ලේඛන හැෂ් ශ්‍රිත වඩාත් අද්විතීය යැයි උපකල්පනය වැරදිය. ඇත්ත වශයෙන්ම එය ප්‍රායෝගිකව බොහෝ විට පසුපසට යන බව පෙන්විය හැකිය. ඇත්ත වශයෙන්ම:

1. ගුප්ත ලේඛන හැෂ් ශ්‍රිතයන් අහඹු ලෙස වෙන් කොට හඳුනාගත නොහැක .
2. නමුත් ගුප්ත ලේඛන නොවන හැෂ් ශ්‍රිත සමඟ, ඔවුන් යෙදවුම් සමඟ වාසිදායක ලෙස මැදිහත් වීම යෝග්‍ය වේ .

එහි අර්ථය වන්නේ ගුප්ත-නොවන හැෂ් ශ්‍රිතයක් සඳහා “හොඳ” දත්ත කට්ටලයක් සඳහා ගුප්ත ලේඛනගත එකකට වඩා අඩු isions ට්ටන තිබිය හැකි බවයි it එය නිර්මාණය කර ඇති දත්ත කට්ටල.

අපට ඇත්ත වශයෙන්ම මෙය නිරූපණය කළ හැක්කේ ඉයන් බොයිඩ්ගේ පිළිතුරේ ඇති දත්ත සහ ටිකක් ගණිතය: උපන්දින ගැටලුව . ඔබ nකට්ටලයෙන් අහඹු ලෙස පූර්ණ සංඛ්‍යා තෝරා ගන්නේ නම් අපේක්ෂිත coll ට්ටන යුගල සංඛ්‍යාවේ සූත්‍රය [1, d]මෙයයි (විකිපීඩියාවෙන් ලබා ගත්):

n - d + d * ((d - 1) / d)^n

බද්ධ n= 216.553 හා d= 2 ^ 32 අප ලබා ඇතැයි අපේක්ෂා ගැටුම් 5.5 . ඉයන් ගේ පරීක්ෂණ බොහෝ දුරට එම අසල්වැසි අවට ප්‍රති results ල පෙන්වයි, නමුත් එක් නාටකාකාර ව්‍යතිරේකයක් සමඟ: බොහෝ ශ්‍රිතයන්ට අඛණ්ඩ සංඛ්‍යා පරීක්ෂණ වලදී ශුන්‍ය isions ට්ටන ලැබුණි . අහඹු ලෙස 216,553 32-බිට් අංක තෝරාගෙන ශුන්‍ය isions ට්ටන ලබා ගැනීමේ සම්භාවිතාව 0.43% ක් පමණ වේ. එය එක් ශ්‍රිතයක් සඳහා පමණි - මෙහි අපට ශුන්‍ය isions ට්ටන සහිත විශේෂිත හැෂ් ශ්‍රිත පවුල් පහක් ඇත !

ඒ නිසා අපි ඉන්නේ මෙතන දුටු ඉයන් පරීක්ෂා කරන කාරීව අන්තර් ක්රියා කරන බව ය සතුටුදායක වන වරටත් අංක දත්ත කාණ්ඩය, එනම්, ඔවුන් කරන්නේ විසිර අවම විවිධ යෙදවුම් වඩා පුළුල් ලෙස කදිම ගුප්ත ෙල්ඛන හැෂ් කාර්යය වඩා ඇත. (පැති සටහන: මෙයින් අදහස් කරන්නේ සංඛ්‍යා දත්ත කට්ටලයේ FNV-1a සහ MurmurHash2 ඔහුට “අහඹු ලෙස පෙනේ” යන ඉයන් ගේ චිත්‍රමය තක්සේරුව ඔහුගේ දත්ත වලින් ප්‍රතික්ෂේප කළ හැකි බවයි. එම ප්‍රමාණයේ දත්ත කට්ටලයක් මත ශුන්‍ය isions ට්ටනය, හැෂ් කාර්යයන් දෙකම සඳහා , කැපී පෙනෙන ලෙස අවිධිමත් ය!)

මෙය පුදුමයක් නොවේ, මන්ද මෙය බොහෝ හැෂ් ශ්‍රිත සඳහා යෝග්‍ය හැසිරීමකි. උදාහරණයක් ලෙස, හැෂ් මේස යතුරු බොහෝ විට බොහෝ සෙයින් සමාන ය; ඉයන් ගේ පිළිතුරෙහි MSN වරක් ZIP කේත හැෂ් වගු සමඟ ඇති ගැටලුවක් සඳහන් කරයි . අහඹු ලෙස සමාන හැසිරීම් වලට වඩා බොහෝ විට යෙදවුම් මත ision ට්ටනය වැළැක්වීම මෙය භාවිතා කරයි.

මෙහි ඇති තවත් උපදේශාත්මක සංසන්දනයක් නම් CRC සහ ගුප්ත ලේඛන හැෂ් කාර්යයන් අතර සැලසුම් ඉලක්කවල වෙනස:

• සී.ආර්.සී. නිර්මාණය කර ඇත්තේ communication ෝෂාකාරී සන්නිවේදන නාලිකා වල ඇති වන දෝෂ හඳුනා ගැනීම සඳහා වන අතර ඒවා කුඩා සංඛ්‍යාවක් විය හැකිය;
• ක්‍රිප්ටෝ හැෂ් නිර්මාණය කර ඇත්තේ අනිෂ්ට ප්‍රහාරකයින් විසින් සිදුකරන ලද වෙනස් කිරීම් අල්ලා ගැනීම සඳහා වන අතර ඔවුන්ට සීමිත පරිගණක සම්පත් ලබා දී ඇති නමුත් අත්තනෝමතික ලෙස බොහෝ දක්ෂතා ඇත.

එබැවින් සීආර්සී සඳහා අවම වශයෙන් වෙනස් යෙදවුම් වල අහඹු ලෙස අඩු isions ට්ටන ඇතිවීම නැවතත් හොඳය . ක්‍රිප්ටෝ හැෂ් සමඟ, මෙය නැත-නැත!

SipHash භාවිතා කරන්න . එයට ප්‍රිය ගුණාංග රාශියක් ඇත :

• ඉක්මනින්. ප්‍රශස්ත ලෙස ක්‍රියාත්මක කිරීම බයිටයකට චක්‍ර 1 ක් පමණ ගත වේ.

• ආරක්ෂිතයි. SipHash යනු ශක්තිමත් PRF (ව්‍යාජ ශ්‍රිතයකි). මෙයින් අදහස් කරන්නේ එය අහඹු ශ්‍රිතයකින් වෙන් කොට හඳුනාගත නොහැකි බවයි (ඔබ බිටු 128 රහස් යතුර නොදන්නේ නම්). එබැවින්:

  • ගැටුම් හේතුවෙන් ඔබගේ හැෂ් මේස පරීක්ෂණ රේඛීය වේලාවක් බවට පත්වීම ගැන කරදර විය යුතු නැත. SipHash සමඟ, යෙදවුම් නොසලකා සාමාන්‍යයෙන් ඔබට සාමාන්‍ය කාර්ය සාධනය ලැබෙනු ඇති බව ඔබ දන්නවා .

  • සේවා ප්‍රහාර ප්‍රතික්ෂේප කිරීම හැෂ් මත පදනම් වූ ප්‍රතිශක්තිය.

  • ඔබට MAP (පණිවිඩ සත්‍යාපන කේතය) ලෙස SipHash (විශේෂයෙන් බිට් 128 ප්‍රතිදානය සහිත අනුවාදය) භාවිතා කළ හැකිය. ඔබට පණිවිඩයක් සහ සිප් හැෂ් ටැගයක් ලැබුනේ නම් සහ ටැගය ඔබේ රහස් යතුර සමඟ සිප් හැෂ් ධාවනය කිරීමෙන් සමාන වේ නම්, ඔබ දන්නවා හැෂ් නිර්මාණය කළ කවුරුන් හෝ ඔබේ රහස් යතුර සතුව ඇති බවත්, පණිවිඩය හෝ පණිවිඩය හෝ නොමැති බවත්. හැෂ් සිට වෙනස් කර ඇත.

එය ඔබ හෑෂ් කරන දත්ත මත රඳා පවතී. සමහර හැෂිං පෙළ වැනි නිශ්චිත දත්ත සමඟ වඩා හොඳින් ක්‍රියා කරයි. සමහර හැෂිං ඇල්ගොරිතම විශේෂිත දත්ත සඳහා හොඳ ලෙස නිර්මාණය කර ඇත.

පෝල් හෙසී වරක් වේගවත් හැෂ් සාදන ලදී . ඔහු මූලාශ්‍ර කේතය සහ පැහැදිලි කිරීම් ලැයිස්තුගත කරයි. නමුත් ඒ වන විටත් එය පරාජය විය. :)

ජාවා මෙය භාවිතා කරයි සරල ගුණ කිරීමේ සහ එකතු කිරීමේ ඇල්ගොරිතම භාවිතා කරයි:

සංගීත වස්තුවක් සඳහා හැෂ් කේතය ගණනය කරනු ලබන්නේ

 s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

int අංක ගණිතය භාවිතා කිරීම, මෙහි නූල් s[i]වල i -th අක්ෂරය, නූල් nවල දිග, සහ^ පෙන්නුම් කරයි. (හිස් නූලෙහි හැෂ් අගය ශුන්‍ය වේ.)

වඩා හොඳ ඒවා එහි ඇති නමුත් මෙය තරමක් පුළුල් වන අතර වේගය සහ සුවිශේෂත්වය අතර හොඳ වෙළඳාමක් ලෙස පෙනේ.

පළමුවෙන්ම, ඔබේම හැෂිං ක්රියාත්මක කිරීමට අවශ්ය වන්නේ ඇයි? බොහෝ කාර්යයන් සඳහා ඔබ සම්මත පුස්තකාලයකින් දත්ත ව්‍යුහයන් සමඟ හොඳ ප්‍රති results ල ලබා ගත යුතුය, ක්‍රියාත්මක කිරීමක් තිබේ යැයි උපකල්පනය කරන්න (ඔබ මෙය ඔබේම අධ්‍යාපනය සඳහා පමණක් නොකරන්නේ නම්).

සැබෑ හැෂිං ඇල්ගොරිතමයන් යන තාක් දුරට, මගේ පුද්ගලික ප්‍රියතමය එෆ්එන්වී ය. 1

C හි 32-bit අනුවාදය ක්‍රියාත්මක කිරීම සඳහා උදාහරණයක් මෙන්න:

unsigned long int FNV_hash(void* dataToHash, unsigned long int length)
{
  unsigned char* p = (unsigned char *) dataToHash;
  unsigned long int h = 2166136261UL;
  unsigned long int i;

  for(i = 0; i < length; i++)
    h = (h * 16777619) ^ p[i] ;

  return h;
}