c++ - 检索16k键-值对的最快方法?

标签 c++ c arrays map hashtable

好,这是我的情况:

  • 我有一个函数-假设U64 calc (U64 x)-它接受64位整数参数,执行一些CPU密集型操作,并返回64位值
  • 现在,考虑到我事先知道该函数的所有可能输入(x)(虽然有16000左右),我认为最好预先计算它们,然后按需获取它们(从类似数组的数组中获取)结构体)。
  • 理想的情况是将它们全部存储在U64 CALC[]数组中,并通过索引(再次是x)检索它们。
  • 这是问题所在:我可能知道calc函数的可能输入是什么,但它们绝对是不是连续的(例如,不是从1到16000,但是值可能会低至0甚至高一些万亿美元-始终在64位范围内)

  • E.G.
      X        CALC[X]
    -----------------------
      123123   123123123
      12312    12312312
      897523   986123
    
      etc.
    

    这是我的问题:
  • 您将如何存储它们?
  • 您想要哪种解决方法?
  • 现在,鉴于这些值(来自CALC),必须每秒对数千到数百万次进行访问,这将是性能最佳的解决方案?


  • 请注意:我没有提及我已经想到或尝试过的任何内容,以免将答案变成关于A vs B的某种辩论,并且大多数情况下不会影响任何人...

    最佳答案

    我将使用某种哈希函数来创建u64对的索引,其中一个是创建密钥的值,另一个是替换值。从技术上讲,如果您需要节省空间,则索引可以是三个字节长(假设为1,600万-“16,000千”对),但我会使用u32。如果存储的值与在(哈希冲突)上计算得出的值不匹配,则将输入溢出处理程序。

  • 您需要确定一种自定义哈希算法以适合您的数据
  • 因为您知道数据的大小,所以不需要允许数据增长的算法。
  • 我会警惕使用一些标准算法,因为它们很少适合特定数据
  • 我会谨慎使用C++方法,除非您确定代码是所见即所得(不会产生很多看不见的调用)
  • 您的索引应该比
  • 对的数量大25%

    遍历所有可能的输入并确定碰撞次数的最小,最大,平均和标准偏差,并使用这些偏差确定可接受的性能水平。然后进行概要分析以获取最佳代码。

    所需的内存空间(使用u32索引)为(4 * 1.25)+ 8 + 8 =每对21字节或336 MeB,在典型PC上没有问题。

    ________编辑________

    我受到“RocketRoy”的挑战,要把钱放到嘴边。开始:

    问题与(固定大小的)哈希索引中的冲突处理有关。设置舞台:
  • 我有n个条目的列表,其中条目中的字段包含值v,该值是根据
  • 计算得出的
  • 我有一个n * 1.25(近似)指数的 vector ,因此指数x的个数是质数
  • 计算素数y,它是x
  • 的分数
  • vector 初始化为-1表示空闲的

  • 很标准的东西,我想你会同意的。

    处理列表中的条目,并计算和对哈希值h进行模和运算,并将其用作 vector 的索引,并将该条目的索引放在此处。

    最终,我遇到了索引所指向的 vector 条目被占用(不包含-1)的情况-voilà,一个冲突。

    那我该怎么办?我将原始h保持为ho,在y上加上y并取x为模,并在 vector 中得到一个新索引。如果该条目未被占用,我将使用它,否则我将以y模x继续添加,直到到达ho为止。从理论上讲,这将发生,因为x和y都是素数。实际上,x大于n,所以不会。

    因此,RocketRoy声称的“重新哈希”非常昂贵,并非如此。

    与所有哈希方法一样,此方法的棘手部分是:
  • 为x确定一个合适的值(最后使用的x越大,难度就越小)
  • 确定h = a(v)%x的算法a,以使h的索引合理平均地(“随机地”)进入索引 vector ,并且冲突尽可能少
  • 确定y的合适值,以使冲突合理平均地(“随机”)索引到索引 vector


  • ________编辑________

    很抱歉,我花了这么长时间来生成此代码...其他事情具有更高的优先级。

    无论如何,这里的代码证明了散列比二叉树具有更好的快速查找前景。它贯穿一系列哈希索引的大小和算法,以帮助找到最适合特定数据的组合。对于每种算法,代码将打印第一个索引大小,以使查找的时间不超过十四次搜索(二进制搜索的最坏情况),平均查找少于1.5次搜索。

    如果您没有注意到,我很喜欢这类应用中的质数。

    创建带有强制溢出处理的哈希算法的方法有很多。我选择简单起见,假设它将转化为速度……而且确实如此。在我的配备i5 M 480 @ 2.67 GHz的笔记本电脑上,平均查找需要55至60个时钟周期(每秒约有4500万次查找)。我实现了一个特殊的get操作,具有不变的indees和ditto rehash值数量,并且周期数减少到40(每秒6500万次查找)。如果查看调用getOpSpec的行,索引i将与0x444进行异或运算以执行缓存以实现更多类似于“真实世界”的结果。

    我必须再次指出,该程序建议针对特定数据的合适组合。其他数据可能需要不同的组合。

    源代码既包含用于生成16000个无符号的long long对,又用于测试不同的常量(索引大小和哈希值)的代码:
    #include <windows.h>
    
    #define i8    signed char
    #define i16          short
    #define i32          long
    #define i64          long long
    #define id  i64
    #define u8           char
    #define u16 unsigned short
    #define u32 unsigned long
    #define u64 unsigned long long
    #define ud  u64
    
    #include <string.h>
    #include <stdio.h>
    
    u64 prime_find_next     (const u64 value);
    u64 prime_find_previous (const u64 value);
    
    static inline volatile unsigned long long rdtsc_to_rax (void)
    {
      unsigned long long lower,upper;
    
      asm volatile( "rdtsc\n"
                    : "=a"(lower), "=d"(upper));
      return lower|(upper<<32);
    }
    
    static u16 index[65536];
    
    static u64 nindeces,rehshFactor;
    
    static struct PAIRS {u64 oval,rval;} pairs[16000] = {
    #include "pairs.h"
    };
    
    struct HASH_STATS
    {
      u64 ninvocs,nrhshs,nworst;
    } getOpStats,putOpStats;
    
    i8 putOp (u16 index[], const struct PAIRS data[], const u64 oval, const u64 ci)
    {
      u64 nworst=1,ho,h,i;
      i8 success=1;
    
      ++putOpStats.ninvocs;
      ho=oval%nindeces;
      h=ho;
      do
      {
        i=index[h];
        if (i==0xffff)    /* unused position */
        {
          index[h]=(u16)ci;
          goto added;
        }
        if (oval==data[i].oval) goto duplicate;
    
        ++putOpStats.nrhshs;
        ++nworst;
    
        h+=rehshFactor;
        if (h>=nindeces) h-=nindeces;
      } while (h!=ho);
    
      exhausted:    /* should not happen */
      duplicate:
        success=0;
    
      added:
      if (nworst>putOpStats.nworst) putOpStats.nworst=nworst;
    
      return success;
    }
    
    i8 getOp (u16 index[], const struct PAIRS data[], const u64 oval, u64 *rval)
    {
      u64 ho,h,i;
      i8 success=1;
    
      ho=oval%nindeces;
      h=ho;
      do
      {
        i=index[h];
        if (i==0xffffu) goto not_found;    /* unused position */
    
        if (oval==data[i].oval)
        {
          *rval=data[i].rval;    /* fetch the replacement value */
          goto found;
        }
    
        h+=rehshFactor;
        if (h>=nindeces) h-=nindeces;
      } while (h!=ho);
    
      exhausted:
      not_found:    /* should not happen */
        success=0;
    
      found:
    
      return success;
    }
    
    volatile i8 stop = 0;
    
    int main (int argc, char *argv[])
    {
      u64 i,rval,mulup,divdown,start;
      double ave;
    
      SetThreadAffinityMask (GetCurrentThread(), 0x00000004ull);
    
      divdown=5;   //5
      while (divdown<=100)
      {
        mulup=3;  // 3
        while (mulup<divdown)
        {
          nindeces=16000;
          while (nindeces<65500)
          {
            nindeces=   prime_find_next     (nindeces);
            rehshFactor=nindeces*mulup/divdown;
            rehshFactor=prime_find_previous (rehshFactor);
    
            memset (index, 0xff, sizeof(index));
            memset (&putOpStats, 0, sizeof(struct HASH_STATS));
    
            i=0;
            while (i<16000)
            {
              if (!putOp (index, pairs, pairs[i].oval, (u16) i)) stop=1;
    
              ++i;
            }
    
            ave=(double)(putOpStats.ninvocs+putOpStats.nrhshs)/(double)putOpStats.ninvocs;
            if (ave<1.5 && putOpStats.nworst<15)
            {
              start=rdtsc_to_rax ();
              i=0;
              while (i<16000)
              {
                if (!getOp (index, pairs, pairs[i^0x0444]. oval, &rval)) stop=1;
                ++i;
              }
              start=rdtsc_to_rax ()-start+8000;   /* 8000 is half of 16000 (pairs), for rounding */
    
              printf ("%u;%u;%u;%u;%1.3f;%u;%u\n", (u32)mulup, (u32)divdown, (u32)nindeces, (u32)rehshFactor, ave, (u32) putOpStats.nworst, (u32) (start/16000ull));
    
              goto found;
            }
    
            nindeces+=2;
          }
          printf ("%u;%u\n", (u32)mulup, (u32)divdown);
    
          found:
          mulup=prime_find_next (mulup);
        }
        divdown=prime_find_next (divdown);
      }
    
      SetThreadAffinityMask (GetCurrentThread(), 0x0000000fu);
    
      return 0;
    }
    

    无法包含生成的结对文件(答案显然限于30000个字符)。但将邮件发送到我的收件箱中,我会邮寄出去。

    这些是结果:
    3;5;35569;21323;1.390;14;73
    3;7;33577;14389;1.435;14;60
    5;7;32069;22901;1.474;14;61
    3;11;35107;9551;1.412;14;59
    5;11;33967;15427;1.446;14;61
    7;11;34583;22003;1.422;14;59
    3;13;34253;7901;1.439;14;61
    5;13;34039;13063;1.443;14;60
    7;13;32801;17659;1.456;14;60
    11;13;33791;28591;1.436;14;59
    3;17;34337;6053;1.413;14;59
    5;17;32341;9511;1.470;14;61
    7;17;32507;13381;1.474;14;62
    11;17;33301;21529;1.454;14;60
    13;17;34981;26737;1.403;13;59
    3;19;33791;5333;1.437;14;60
    5;19;35149;9241;1.403;14;59
    7;19;33377;12289;1.439;14;97
    11;19;34337;19867;1.417;14;59
    13;19;34403;23537;1.430;14;61
    17;19;33923;30347;1.467;14;61
    3;23;33857;4409;1.425;14;60
    5;23;34729;7547;1.429;14;60
    7;23;32801;9973;1.456;14;61
    11;23;33911;16127;1.445;14;60
    13;23;33637;19009;1.435;13;60
    17;23;34439;25453;1.426;13;60
    19;23;33329;27529;1.468;14;62
    3;29;32939;3391;1.474;14;62
    5;29;34543;5953;1.437;13;60
    7;29;34259;8263;1.414;13;59
    11;29;34367;13033;1.409;14;60
    13;29;33049;14813;1.444;14;60
    17;29;34511;20219;1.422;14;60
    19;29;33893;22193;1.445;13;61
    23;29;34693;27509;1.412;13;92
    3;31;34019;3271;1.441;14;60
    5;31;33923;5449;1.460;14;61
    7;31;33049;7459;1.442;14;60
    11;31;35897;12721;1.389;14;59
    13;31;35393;14831;1.397;14;59
    17;31;33773;18517;1.425;14;60
    19;31;33997;20809;1.442;14;60
    23;31;34841;25847;1.417;14;59
    29;31;33857;31667;1.426;14;60
    3;37;32569;2633;1.476;14;61
    5;37;34729;4691;1.419;14;59
    7;37;34141;6451;1.439;14;60
    11;37;34549;10267;1.410;13;60
    13;37;35117;12329;1.423;14;60
    17;37;34631;15907;1.429;14;63
    19;37;34253;17581;1.435;14;60
    23;37;32909;20443;1.453;14;61
    29;37;33403;26177;1.445;14;60
    31;37;34361;28771;1.413;14;59
    3;41;34297;2503;1.424;14;60
    5;41;33587;4093;1.430;14;60
    7;41;34583;5903;1.404;13;59
    11;41;32687;8761;1.440;14;60
    13;41;34457;10909;1.439;14;60
    17;41;34337;14221;1.425;14;59
    19;41;32843;15217;1.476;14;62
    23;41;35339;19819;1.423;14;59
    29;41;34273;24239;1.436;14;60
    31;41;34703;26237;1.414;14;60
    37;41;33343;30089;1.456;14;61
    3;43;34807;2423;1.417;14;59
    5;43;35527;4129;1.413;14;60
    7;43;33287;5417;1.467;14;61
    11;43;33863;8647;1.436;14;60
    13;43;34499;10427;1.418;14;78
    17;43;34549;13649;1.431;14;60
    19;43;33749;14897;1.429;13;60
    23;43;34361;18371;1.409;14;59
    29;43;33149;22349;1.452;14;61
    31;43;34457;24821;1.428;14;60
    37;43;32377;27851;1.482;14;81
    41;43;33623;32057;1.424;13;59
    3;47;33757;2153;1.459;14;61
    5;47;33353;3547;1.445;14;61
    7;47;34687;5153;1.414;13;59
    11;47;34519;8069;1.417;14;60
    13;47;34549;9551;1.412;13;59
    17;47;33613;12149;1.461;14;61
    19;47;33863;13687;1.443;14;60
    23;47;35393;17317;1.402;14;59
    29;47;34747;21433;1.432;13;60
    31;47;34871;22993;1.409;14;59
    37;47;34729;27337;1.425;14;59
    41;47;33773;29453;1.438;14;60
    43;47;31253;28591;1.487;14;62
    3;53;33623;1901;1.430;14;59
    5;53;34469;3229;1.430;13;60
    7;53;34883;4603;1.408;14;59
    11;53;34511;7159;1.412;13;59
    13;53;32587;7963;1.453;14;60
    17;53;34297;10993;1.432;13;80
    19;53;33599;12043;1.443;14;64
    23;53;34337;14897;1.415;14;59
    29;53;34877;19081;1.424;14;61
    31;53;34913;20411;1.406;13;59
    37;53;34429;24029;1.417;13;60
    41;53;34499;26683;1.418;14;59
    43;53;32261;26171;1.488;14;62
    47;53;34253;30367;1.437;14;79
    3;59;33503;1699;1.432;14;61
    5;59;34781;2939;1.424;14;60
    7;59;35531;4211;1.403;14;59
    11;59;34487;6427;1.420;14;59
    13;59;33563;7393;1.453;14;61
    17;59;34019;9791;1.440;14;60
    19;59;33967;10937;1.447;14;60
    23;59;33637;13109;1.438;14;60
    29;59;34487;16943;1.424;14;59
    31;59;32687;17167;1.480;14;61
    37;59;35353;22159;1.404;14;59
    41;59;34499;23971;1.431;14;60
    43;59;34039;24799;1.445;14;60
    47;59;32027;25471;1.499;14;62
    53;59;34019;30557;1.449;14;61
    3;61;35059;1723;1.418;14;60
    5;61;34351;2803;1.416;13;60
    7;61;35099;4021;1.412;14;59
    11;61;34019;6133;1.442;14;60
    13;61;35023;7459;1.406;14;88
    17;61;35201;9803;1.414;14;61
    19;61;34679;10799;1.425;14;101
    23;61;34039;12829;1.441;13;60
    29;61;33871;16097;1.446;14;60
    31;61;34147;17351;1.427;14;61
    37;61;34583;20963;1.412;14;59
    41;61;32999;22171;1.452;14;62
    43;61;33857;23857;1.431;14;98
    47;61;34897;26881;1.431;14;60
    53;61;33647;29231;1.434;14;60
    59;61;32999;31907;1.454;14;60
    3;67;32999;1471;1.455;14;61
    5;67;35171;2621;1.403;14;59
    7;67;33851;3533;1.463;14;61
    11;67;34607;5669;1.437;14;60
    13;67;35081;6803;1.416;14;61
    17;67;33941;8609;1.417;14;60
    19;67;34673;9829;1.427;14;60
    23;67;35099;12043;1.415;14;60
    29;67;33679;14563;1.452;14;61
    31;67;34283;15859;1.437;14;60
    37;67;32917;18169;1.460;13;61
    41;67;33461;20443;1.441;14;61
    43;67;34313;22013;1.426;14;60
    47;67;33347;23371;1.452;14;61
    53;67;33773;26713;1.434;14;60
    59;67;35911;31607;1.395;14;58
    61;67;34157;31091;1.431;14;63
    3;71;34483;1453;1.423;14;59
    5;71;34537;2423;1.428;14;59
    7;71;33637;3313;1.428;13;60
    11;71;32507;5023;1.465;14;79
    13;71;35753;6529;1.403;14;59
    17;71;33347;7963;1.444;14;61
    19;71;35141;9397;1.410;14;59
    23;71;32621;10559;1.475;14;61
    29;71;33637;13729;1.429;14;60
    31;71;33599;14657;1.443;14;60
    37;71;34361;17903;1.396;14;59
    41;71;33757;19489;1.435;14;61
    43;71;34583;20939;1.413;14;59
    47;71;34589;22877;1.441;14;60
    53;71;35353;26387;1.418;14;59
    59;71;35323;29347;1.406;14;59
    61;71;35597;30577;1.401;14;59
    67;71;34537;32587;1.425;14;59
    3;73;34613;1409;1.418;14;59
    5;73;32969;2251;1.453;14;62
    7;73;33049;3167;1.448;14;61
    11;73;33863;5101;1.435;14;60
    13;73;34439;6131;1.456;14;60
    17;73;33629;7829;1.455;14;61
    19;73;34739;9029;1.421;14;60
    23;73;33071;10399;1.469;14;61
    29;73;33359;13249;1.460;14;61
    31;73;33767;14327;1.422;14;59
    37;73;32939;16693;1.490;14;62
    41;73;33739;18947;1.438;14;60
    43;73;33937;19979;1.432;14;61
    47;73;33767;21739;1.422;14;59
    53;73;33359;24203;1.435;14;60
    59;73;34361;27767;1.401;13;59
    61;73;33827;28229;1.443;14;60
    67;73;34421;31583;1.423;14;71
    71;73;33053;32143;1.447;14;60
    3;79;35027;1327;1.410;14;60
    5;79;34283;2161;1.432;14;60
    7;79;34439;3049;1.432;14;60
    11;79;34679;4817;1.416;14;59
    13;79;34667;5701;1.405;14;59
    17;79;33637;7237;1.428;14;60
    19;79;34469;8287;1.417;14;60
    23;79;34439;10009;1.433;14;60
    29;79;33427;12269;1.448;13;61
    31;79;33893;13297;1.445;14;61
    37;79;33863;15823;1.439;14;60
    41;79;32983;17107;1.450;14;60
    43;79;34613;18803;1.431;14;60
    47;79;33457;19891;1.457;14;61
    53;79;33961;22777;1.435;14;61
    59;79;32983;24631;1.465;14;60
    61;79;34337;26501;1.428;14;60
    67;79;33547;28447;1.458;14;61
    71;79;32653;29339;1.473;14;61
    73;79;34679;32029;1.429;14;64
    3;83;35407;1277;1.405;14;59
    5;83;32797;1973;1.451;14;60
    7;83;33049;2777;1.443;14;61
    11;83;33889;4483;1.431;14;60
    13;83;35159;5503;1.409;14;59
    17;83;34949;7151;1.412;14;59
    19;83;32957;7541;1.467;14;61
    23;83;32569;9013;1.470;14;61
    29;83;33287;11621;1.474;14;61
    31;83;33911;12659;1.448;13;60
    37;83;33487;14923;1.456;14;62
    41;83;33587;16573;1.438;13;60
    43;83;34019;17623;1.435;14;60
    47;83;31769;17987;1.483;14;62
    53;83;33049;21101;1.451;14;61
    59;83;32369;23003;1.465;14;61
    61;83;32653;23993;1.469;14;61
    67;83;33599;27109;1.437;14;61
    71;83;33713;28837;1.452;14;61
    73;83;33703;29641;1.454;14;61
    79;83;34583;32911;1.417;14;59
    3;89;34147;1129;1.415;13;60
    5;89;32797;1831;1.461;14;61
    7;89;33679;2647;1.443;14;73
    11;89;34543;4261;1.427;13;60
    13;89;34603;5051;1.419;14;60
    17;89;34061;6491;1.444;14;60
    19;89;34457;7351;1.422;14;79
    23;89;33529;8663;1.450;14;61
    29;89;34283;11161;1.431;14;60
    31;89;35027;12197;1.411;13;59
    37;89;34259;14221;1.403;14;59
    41;89;33997;15649;1.434;14;60
    43;89;33911;16127;1.445;14;60
    47;89;34949;18451;1.419;14;59
    53;89;34367;20443;1.434;14;60
    59;89;33791;22397;1.430;14;59
    61;89;34961;23957;1.404;14;59
    67;89;33863;25471;1.433;13;60
    71;89;35149;28031;1.414;14;79
    73;89;33113;27143;1.447;14;60
    79;89;32909;29209;1.458;14;61
    83;89;33617;31337;1.400;14;59
    3;97;34211;1051;1.448;14;60
    5;97;34807;1789;1.430;14;60
    7;97;33547;2417;1.446;14;60
    11;97;35171;3967;1.407;14;89
    13;97;32479;4349;1.474;14;61
    17;97;34319;6011;1.444;14;60
    19;97;32381;6337;1.491;14;64
    23;97;33617;7963;1.421;14;59
    29;97;33767;10093;1.423;14;59
    31;97;33641;10739;1.447;14;60
    37;97;34589;13187;1.425;13;60
    41;97;34171;14437;1.451;14;60
    43;97;31973;14159;1.484;14;62
    47;97;33911;16127;1.445;14;61
    53;97;34031;18593;1.448;14;80
    59;97;32579;19813;1.457;14;61
    61;97;34421;21617;1.417;13;60
    67;97;33739;23297;1.448;14;60
    71;97;33739;24691;1.435;14;60
    73;97;33863;25471;1.433;13;60
    79;97;34381;27997;1.419;14;59
    83;97;33967;29063;1.446;14;60
    89;97;33521;30727;1.441;14;60
    

    第1列和第2列用于计算重新哈希值和索引大小之间的粗略关系。接下来的两个是第一个索引大小/重新混合因子组合,平均查找次数少于1.5次,最坏情况是14次查找。然后是平均情况和最坏情况。最后,最后一列是每次查询的平均时钟周期数。它没有考虑读取时间戳寄存器所需的时间。

    最佳常数的实际存储空间(索引数= 31253,重新哈希因子= 28591)超出了我最初指示的数量(16000 * 2 * 8 + 1,25 * 16000 * 2 => 296000字节)。实际大小是16000 * 2 * 8 + 31253 * 2 => 318506。

    最快的组合是11/31的近似比率,索引大小为35897,重新哈希值为12721。这将平均为1.389(1次初始哈希+ 0.389重新哈希),最大值为14(1 + 13)。

    ________编辑________

    我删除了“找到的goto”;在main()中显示所有组合,它表明可以有更好的性能,当然是以更大的索引大小为代价的。例如,组合57667和33797的平均值为1.192,最大哈希为6。组合44543和23399的平均值为1.249,最大哈希为10(与索引表相比,它节省(57667-44543)* 2 = 26468字节) 57667/33797)。

    与变量相比,具有硬编码哈希索引大小和重新哈希因子的专用函数将在60-70%的时间内执行。这可能是由于编译器(gcc 64位)用乘法代替了模,并且不必从内存位置获取值,因为它们将被编码为立即值。

    ________编辑________

    关于缓存,我看到两个问题。

    首先是数据缓存,我认为这是不可能的,因为查找只是较大过程中的一小步,并且冒着表数据的缓存行在较小程度上(或可能更大程度)开始失效的风险- (如果不是全部的话)-通过较大过程的其他步骤中的其他数据访问。也就是说,整个过程中执行的代码越多,访问的数据越少,任何相关的查找数据将保留在缓存中的可能性就越小(这可能与OP的情况有关或无关)。要使用(我的)哈希查找条目,您将需要进行的每个比较都遇到两个缓存未命中(一个加载索引的正确部分,另一个加载包含条目本身的区域)。在第一次尝试中找到一个条目将导致两次未命中,第二次尝试将导致四个未命中。在我的示例中,每次查找的60个时钟周期平均花费意味着该表可能完全位于L2高速缓存中,而L1不必进入该高速缓存中。大多数情况下。我的x86-64 CPU具有L1-3,RAM等待状态大约为4、10、40和100,对我来说,这表明RAM完全被拒之门外,而L3则最多。

    第二个是代码缓存,如果它很小,紧凑,内联并且几乎没有控制传输(跳转和调用),它将产生更大的影响。我的哈希例程可能完全驻留在L1代码缓存中。对于更正常的情况,代码缓存行加载的数量越少,速度就会越快。

    关于c++ - 检索16k键-值对的最快方法?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/13898687/

    相关文章:

    c++ - 用零 eigen3 c++ 替换所有负元素

    c - HTTP 服务器和 CGI​​ 处理

    php - 特定数组键的返回值

    C++ 访问上层作用域而不是全局

    c++ - kernel.cpp 在制作 kernel.o 时显示错误和 Makefile 错误

    android - getsockname 返回-1,errno 是 EBADF?

    c - 有没有办法从c中的基地址获取完整数组?

    Javascript 和 jQuery 数组未定义

    jquery - 如何使用序列化并发送ajax(johnny sortable插件)

    c++ - size_t 在 C++ 中转换/转换为字符串