Ignore:
Timestamp:
Sep 16, 2006, 4:37:51 PM (19 years ago)
Author:
bird
Message:

tuning. libc is 1-2 seconds faster to load now.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gmake/variable.c

    r520 r526  
    110110typedef signed short int int16_t;
    111111# endif
    112 static inline unsigned long variable_hash_b(register const unsigned char *var, register int length)
    113 {
    114     register unsigned long hash = 0;
    115     for (;;)
    116     {
    117         switch (length)
    118         {
    119             default:
    120             case 16: hash = *var++ + (hash << 6) + (hash << 16) - hash;
    121             case 15: hash = *var++ + (hash << 6) + (hash << 16) - hash;
    122             case 14: hash = *var++ + (hash << 6) + (hash << 16) - hash;
    123             case 13: hash = *var++ + (hash << 6) + (hash << 16) - hash;
    124             case 12: hash = *var++ + (hash << 6) + (hash << 16) - hash;
    125             case 11: hash = *var++ + (hash << 6) + (hash << 16) - hash;
    126             case 10: hash = *var++ + (hash << 6) + (hash << 16) - hash;
    127             case 9:  hash = *var++ + (hash << 6) + (hash << 16) - hash;
    128             case 8:  hash = *var++ + (hash << 6) + (hash << 16) - hash;
    129             case 7:  hash = *var++ + (hash << 6) + (hash << 16) - hash;
    130             case 6:  hash = *var++ + (hash << 6) + (hash << 16) - hash;
    131             case 5:  hash = *var++ + (hash << 6) + (hash << 16) - hash;
    132             case 4:  hash = *var++ + (hash << 6) + (hash << 16) - hash;
    133             case 3:  hash = *var++ + (hash << 6) + (hash << 16) - hash;
    134             case 2:  hash = *var++ + (hash << 6) + (hash << 16) - hash;
    135             case 1:  hash = *var++ + (hash << 6) + (hash << 16) - hash;
    136             case 0:
    137                 break;
    138         }
    139         if (length <= 16)
     112static inline unsigned long variable_hash_2i(register const unsigned char *var, register int length)
     113{
     114    register unsigned int hash = 0;
     115    var += length;
     116    switch (length)
     117    {
     118        default:
     119        case 16: hash = *--var + (hash << 6) + (hash << 16) - hash;
     120        case 15: hash = *--var + (hash << 6) + (hash << 16) - hash;
     121        case 14: hash = *--var + (hash << 6) + (hash << 16) - hash;
     122        case 13: hash = *--var + (hash << 6) + (hash << 16) - hash;
     123        case 12: hash = *--var + (hash << 6) + (hash << 16) - hash;
     124        case 11: hash = *--var + (hash << 6) + (hash << 16) - hash;
     125        case 10: hash = *--var + (hash << 6) + (hash << 16) - hash;
     126        case 9:  hash = *--var + (hash << 6) + (hash << 16) - hash;
     127        case 8:  hash = *--var + (hash << 6) + (hash << 16) - hash;
     128        case 7:  hash = *--var + (hash << 6) + (hash << 16) - hash;
     129        case 6:  hash = *--var + (hash << 6) + (hash << 16) - hash;
     130        case 5:  hash = *--var + (hash << 6) + (hash << 16) - hash;
     131        case 4:  hash = *--var + (hash << 6) + (hash << 16) - hash;
     132        case 3:  hash = *--var + (hash << 6) + (hash << 16) - hash;
     133        case 2:  hash = *--var + (hash << 6) + (hash << 16) - hash;
     134        case 1:  hash = *--var + (hash << 6) + (hash << 16) - hash;
     135        case 0:
    140136            break;
    141         length -= 16;
    142137    }
    143138    return hash;
    144139}
    145140
    146 static inline unsigned long variable_hash_a(register const unsigned char *var, register int length)
    147 {
    148     register unsigned long hash = ((5381 << 5) + 5381) + *var;
     141static inline unsigned long variable_hash_1i(register const unsigned char *var, register int length)
     142{
     143    register unsigned int hash = ((5381 << 5) + 5381) + *var;
    149144    switch (length)
    150145    {
    … …  
    169164#ifdef VARIABLE_HASH /* bird */
    170165# ifdef VARIABLE_HASH_STRICT
    171   if (key->hash1 != variable_hash_a (key->name, key->length))
     166  if (key->hash1 != variable_hash_1i (key->name, key->length))
    172167    __asm__("int3");
    173   if (key->hash2 && key->hash2 != variable_hash_b (key->name, key->length))
     168  if (key->hash2 && key->hash2 != variable_hash_2i (key->name, key->length))
    174169    __asm__("int3");
    175170# endif
    … …  
    177172#else
    178173# ifdef KMK
    179   return variable_hash_a (key->name, key->length);
     174  return variable_hash_1i (key->name, key->length);
    180175# else
    181176  return_STRING_N_HASH_1 (key->name, key->length);
    … …  
    190185  struct variable *key = (struct variable *) keyv;
    191186  if (!key->hash2)
    192     key->hash2 = variable_hash_b (key->name, key->length);
     187    key->hash2 = variable_hash_2i (key->name, key->length);
    193188  return key->hash2;
    194189#else
    195190  struct variable const *key = (struct variable const *) keyv;
    196191# ifdef KMK
    197   return variable_hash_b (key->name, key->length);
     192  return variable_hash_2i (key->name, key->length);
    198193# else
    199194  return_STRING_N_HASH_2 (key->name, key->length);
    … …  
    210205  if (result)
    211206    return result;
     207#ifdef VARIABLE_HASH_STRICT /* bird */
     208  if (x->hash1 != variable_hash_1i (x->name, x->length))
     209    __asm__("int3");
     210  if (x->hash2 && x->hash2 != variable_hash_2i (x->name, x->length))
     211    __asm__("int3");
     212  if (y->hash1 != variable_hash_1i (y->name, y->length))
     213    __asm__("int3");
     214  if (y->hash2 && y->hash2 != variable_hash_2i (y->name, y->length))
     215    __asm__("int3");
     216#endif
     217#ifdef VARIABLE_HASH
     218  /* hash 1 */
     219  result = x->hash1 - y->hash1;
     220  if (result)
     221    return result;
     222#endif
    212223#ifdef KMK /* bird: speed */
    213224  {
    … …  
    249260  }
    250261#endif /* KMK */
    251 #ifdef VARIABLE_HASH_STRICT /* bird */
    252   if (x->hash1 != variable_hash_a (x->name, x->length))
    253     __asm__("int3");
    254   if (x->hash2 && x->hash2 != variable_hash_b (x->name, x->length))
    255     __asm__("int3");
    256   if (y->hash1 != variable_hash_a (y->name, y->length))
    257     __asm__("int3");
    258   if (y->hash2 && y->hash2 != variable_hash_b (y->name, y->length))
    259     __asm__("int3");
    260 #endif
    261262#ifdef VARIABLE_HASH
    262 
    263   /* hash 1 */
    264   result = (int)x->hash1 - (int)y->hash1;
     263  /* hash 2 */
     264  if (!x->hash2)
     265    ((struct variable *)x)->hash2 = variable_hash_2i (x->name, x->length);
     266  if (!y->hash2)
     267    ((struct variable *)y)->hash2 = variable_hash_2i (y->name, y->length);
     268  result = x->hash2 - y->hash2;
    265269  if (result)
    266270    return result;
    267 
    268   /* hash 2 */
    269   if (x->hash2 && y->hash2)
    270     {
    271       result = (int)x->hash2 - (int)y->hash2;
    272       if (result)
    273         return result;
    274     }
    275271#endif
    276272#ifdef KMK
    … …  
    304300  hash_init (&global_variable_set.table,
    305301#ifdef KMK
    306              16383,
     302             16384,
    307303#else
    308304             VARIABLE_BUCKETS,
    … …  
    334330  var_key.length = length;
    335331#ifdef VARIABLE_HASH /* bird */
    336   var_key.hash1 = variable_hash_a (name, length);
     332  var_key.hash1 = variable_hash_1i (name, length);
    337333  var_key.hash2 = 0;
    338334#endif
    … …  
    374370  v->length = length;
    375371#ifdef VARIABLE_HASH /* bird */
    376   v->hash1 = variable_hash_a (name, length);
     372  v->hash1 = variable_hash_1i (name, length);
    377373  v->hash2 = 0;
    378374#endif
    … …  
    515511  var_key.length = length;
    516512#ifdef VARIABLE_HASH /* bird */
    517   var_key.hash1 = variable_hash_a (name, length);
     513  var_key.hash1 = variable_hash_1i (name, length);
    518514  var_key.hash2 = 0;
    519515#endif
    … …  
    522518       setlist != 0; setlist = setlist->next)
    523519    {
     520#ifdef VARIABLE_HASH /* bird: speed */
     521      struct hash_table *ht = &setlist->set->table;
     522      unsigned int hash_1 = var_key.hash1;
     523      struct variable *v;
     524
     525      ht->ht_lookups++;
     526      for (;;)
     527        {
     528          hash_1 &= (ht->ht_size - 1);
     529          v = (struct variable *)ht->ht_vec[hash_1];
     530
     531          if (v == 0)
     532              break;
     533          if ((void *)v != hash_deleted_item)
     534            {
     535              if (variable_hash_cmp(&var_key, v) == 0)
     536                {
     537# ifdef VARIABLE_HASH_STRICT /* bird */
     538                  struct variable *v2 = (struct variable *) hash_find_item ((struct hash_table *) &setlist->set->table, &var_key);
     539                  assert(v2 == v);
     540# endif
     541                  return v->special ? handle_special_var (v) : v;
     542                }
     543              ht->ht_collisions++;
     544            }
     545          if (!var_key.hash2)
     546             var_key.hash2 = variable_hash_2i(name, length);
     547          hash_1 += (var_key.hash2 | 1);
     548        }
     549
     550#else /* !VARIABLE_HASH */
    524551      const struct variable_set *set = setlist->set;
    525552      struct variable *v;
    … …  
    528555      if (v)
    529556        return v->special ? handle_special_var (v) : v;
     557#endif /* !VARIABLE_HASH */
    530558    }
    531559
    … …  
    604632  var_key.length = length;
    605633#ifdef VARIABLE_HASH /* bird */
    606   var_key.hash1 = variable_hash_a (name, length);
     634  var_key.hash1 = variable_hash_1i (name, length);
    607635  var_key.hash2 = 0;
    608636#endif
    … …  
    11381166  makelevel_key.length = MAKELEVEL_LENGTH;
    11391167#ifdef VARIABLE_HASH /* bird */
    1140   makelevel_key.hash1 = variable_hash_a (MAKELEVEL_NAME, MAKELEVEL_LENGTH);
     1168  makelevel_key.hash1 = variable_hash_1i (MAKELEVEL_NAME, MAKELEVEL_LENGTH);
    11411169  makelevel_key.hash2 = 0;
    11421170#endif
    … …  
    12001228  int append = 0;
    12011229  int conditional = 0;
     1230  const size_t varname_len = strlen (varname); /* bird */
    12021231
    12031232  /* Calculate the variable's new value in VALUE.  */
    … …  
    12191248      /* A conditional variable definition "var ?= value".
    12201249         The value is set IFF the variable is not defined yet. */
    1221       v = lookup_variable (varname, strlen (varname));
     1250      v = lookup_variable (varname, varname_len);
    12221251      if (v)
    12231252        return v;
    … …  
    12381267          {
    12391268            append = 1;
    1240             v = lookup_variable_in_set (varname, strlen (varname),
     1269            v = lookup_variable_in_set (varname, varname_len,
    12411270                                        current_variable_set_list->set);
    12421271
    … …  
    12471276          }
    12481277        else
    1249           v = lookup_variable (varname, strlen (varname));
     1278          v = lookup_variable (varname, varname_len);
    12501279
    12511280        if (v == 0)
    … …  
    13161345                *p = '/';
    13171346            }
    1318           v = define_variable_loc (varname, strlen (varname),
     1347          v = define_variable_loc (varname, varname_len,
    13191348                                   shellpath, origin, flavor == f_recursive,
    13201349                                   flocp);
    … …  
    13571386                    *p = '/';
    13581387                }
    1359               v = define_variable_loc (varname, strlen (varname),
     1388              v = define_variable_loc (varname, varname_len,
    13601389                                       shellpath, origin,
    13611390                                       flavor == f_recursive, flocp);
    13621391            }
    13631392          else
    1364             v = lookup_variable (varname, strlen (varname));
     1393            v = lookup_variable (varname, varname_len);
    13651394
    13661395          free (path_string);
    … …  
    13701399#endif /* __MSDOS__ */
    13711400#ifdef WINDOWS32
    1372   if ((origin == o_file || origin == o_override || origin == o_command)
     1401  if (   varname_len == sizeof("SHELL") - 1 /* bird */
     1402      && (origin == o_file || origin == o_override || origin == o_command)
    13731403      && streq (varname, "SHELL"))
    13741404    {
    … …  
    13811411      if (find_and_set_default_shell (p))
    13821412        {
    1383           v = define_variable_in_set (varname, strlen (varname), default_shell,
     1413          v = define_variable_in_set (varname, varname_len, default_shell,
    13841414                                      origin, flavor == f_recursive,
    13851415                                      (target_var
    … …  
    13901420        }
    13911421      else
    1392         v = lookup_variable (varname, strlen (varname));
     1422        v = lookup_variable (varname, varname_len);
    13931423    }
    13941424  else
    … …  
    14011431     make sure we define this variable in the global set.  */
    14021432
    1403   v = define_variable_in_set (varname, strlen (varname), p,
     1433  v = define_variable_in_set (varname, varname_len, p,
    14041434                              origin, flavor == f_recursive,
    14051435                              (target_var
Note: See TracChangeset for help on using the changeset viewer.