VirtualBox

Changeset 526 in kBuild


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

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

Location:
trunk/src/gmake
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gmake/config.h.W32

    r503 r526  
    228228
    229229/* Define to 1 if you have the `strdup' function. */
    230 /* #define HAVE_STRDUP 1*/
     230#define HAVE_STRDUP 1 /* bird */
    231231
    232232/* Define to 1 if you have the `strerror' function. */
    … …  
    488488#undef BATCH_MODE_ONLY_SHELL
    489489#endif
     490
     491/* bird hacks */
     492#include <sys/stat.h>
     493extern int my_stat(const char *, struct stat *);
     494#define stat(_path, _st) my_stat(_path, _st)

  • trunk/src/gmake/expand.c

    r503 r526  
    158158/* Expand a simple reference to variable NAME, which is LENGTH chars long.  */
    159159
    160 #ifdef __GNUC__
     160#if defined(__GNUC__) || defined(_MSC_VER) /* bird added MSC */
    161161__inline
    162162#endif

  • trunk/src/gmake/function.c

    r520 r526  
    3232# include "pathstuff.h"
    3333#endif
     34#include <assert.h> /* bird */
    3435
    3536
    … …  
    261262
    262263
     264/* The maximum length of a function, once reached there is
     265   it can't be function and we can skip the hash lookup drop out. */
     266
     267#define MAX_FUNCTION_LENGTH 10 /* bird */
     268
    263269/* Look up a function by name.  */
    264 
     270#if defined(__GNUC__) || defined(_MSC_VER)
     271__inline
     272#endif
    265273static const struct function_table_entry *
    266274lookup_function (const char *s)
    267275{
    268276  const char *e = s;
    269 
     277#ifdef MAX_FUNCTION_LENGTH
     278  int left = MAX_FUNCTION_LENGTH;
     279  int ch;
     280  while (((ch = *e) >= 'a' && ch <='z') || ch == '-')
     281    {
     282      if (!left--)
     283        return 0;
     284      e++;
     285    }
     286#else
    270287  while (*e && ( (*e >= 'a' && *e <= 'z') || *e == '-'))
    271288    e++;
     289#endif
    272290  if (*e == '\0' || isblank ((unsigned char) *e))
    273291    {
    … …  
    21982216   *STRINGP past the reference and returning nonzero.  If not, return zero.  */
    21992217
    2200 int
    2201 handle_function (char **op, char **stringp)
    2202 {
    2203   const struct function_table_entry *entry_p;
     2218static int
     2219handle_function2 (const struct function_table_entry *entry_p, char **op, char **stringp) /* bird split it up. */
     2220{
    22042221  char openparen = (*stringp)[0];
    22052222  char closeparen = openparen == '(' ? ')' : '}';
    … …  
    22132230  beg = *stringp + 1;
    22142231
    2215   entry_p = lookup_function (beg);
    2216 
    2217   if (!entry_p)
    2218     return 0;
    2219 
    22202232  /* We found a builtin function.  Find the beginning of its arguments (skip
    22212233     whitespace after the name).  */
    … …  
    22982310
    22992311  return 1;
     2312}
     2313
     2314int
     2315handle_function (char **op, char **stringp) /* bird split it up */
     2316{
     2317  const struct function_table_entry *entry_p = lookup_function (*stringp + 1);
     2318  if (!entry_p)
     2319    return 0;
     2320  return handle_function2 (entry_p, op, stringp);
    23002321}
    23012322
    … …  
    24162437  hash_load (&function_table, function_table_init,
    24172438             FUNCTION_TABLE_ENTRIES, sizeof (struct function_table_entry));
    2418 }
     2439#ifdef MAX_FUNCTION_LENGTH /* bird */
     2440  {
     2441    unsigned i;
     2442    for (i = 0; i < FUNCTION_TABLE_ENTRIES; i++)
     2443        assert(function_table_init[i].len <= MAX_FUNCTION_LENGTH);
     2444  }
     2445#endif
     2446}

  • trunk/src/gmake/kmkbuiltin/mscfakes.h

    r370 r526  
    120120#if _MSC_VER < 1400
    121121int snprintf(char *buf, size_t size, const char *fmt, ...);
     122#else
     123#define snprintf _snprintf
    122124#endif
    123125size_t strlcpy(char *, const char *, size_t);

  • 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

  • trunk/src/gmake/variable.h

    r520 r526  
    5454    int length;                 /* strlen (name) */
    5555#ifdef VARIABLE_HASH /* bird */
    56     long hash1;                 /* the primary hash */
    57     long hash2;                 /* the secondary hash */
     56    int hash1;                  /* the primary hash */
     57    int hash2;                  /* the secondary hash */
    5858#endif
    5959    char *value;                /* Variable value.  */

  • trunk/src/gmake/w32/pathstuff.c

    r520 r526  
    234234}
    235235
     236#undef stat
    236237/*
    237238 * Workaround for directory names with trailing slashes.
    … …  
    239240 */
    240241int
    241 stat(const char *path, struct stat *st)
    242 {
    243     int rc = _stat(path, (struct _stat *)st);
     242my_stat(const char *path, struct stat *st)
     243{
     244    int rc = stat(path, st);
    244245    if (    rc != 0
    245246        &&  errno == ENOENT
    … …  
    255256            tmp[len_path + 1] = '\0';
    256257            errno = 0;
    257             rc = _stat(tmp, (struct _stat *)st);
     258            rc = stat(tmp, st);
    258259            if (    rc == 0
    259260                &&  !S_ISDIR(st->st_mode))
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette