Changeset 533 for trunk/src

Timestamp:

Sep 18, 2006, 5:02:39 AM (19 years ago)

Author:

bird

Message:

o Optimization summary: libc from ~21 seconds -> 7-8 seconds (os2/nt).
o Optimized appending new stuff to variables. (major win)
o Optimized variable memory value allocation avoiding a bunch of

unnecessary copying and allocating.

Location:

trunk/src/gmake

Files:

• Makefile.kmk (modified) (1 diff)
• expand.c (modified) (1 diff)
• function.c (modified) (3 diffs)
• variable.c (modified) (8 diffs)
• variable.h (modified) (2 diffs)

trunk/src/gmake/Makefile.kmk

@@ -23 +23 @@
     CONFIG_WITH_INCLUDEDEP \
         CONFIG_WITH_TOUPPER_TOLOWER \
+        KMK \
+        \
+        KMK_HELPERS \
+        VARIABLE_HASH \
+        CONFIG_WITH_OPTIMIZATION_HACKS \
         CONFIG_WITH_VALUE_LENGTH \
-        CONFIG_WITH_COMPARE \
-        KMK \
-        CONFIG_WITH_OPTIMIZATION_HACKS \
-        VARIABLE_HASH
-        
+        CONFIG_WITH_COMPARE
+
 kmk_SOURCES = \
         main.c \

trunk/src/gmake/expand.c

@@ -537 +537 @@
 }
 
+#ifdef CONFIG_WITH_VALUE_LENGTH
+/* Expands the specified string, appending it to the specified variable value. */
+void 
+append_expanded_string_to_variable (struct variable *v, char *value)
+{
+  char *p;
+
+  /* switch the variable buffer to the variable value buffer. */
+  char *saved_buffer = variable_buffer;
+  unsigned int saved_buffer_length = variable_buffer_length;
+  variable_buffer = v->value;
+  variable_buffer_length = v->value_alloc_len;
+
+  /* skip the current value and start appending a space and the expanded string. */
+  p = v->value + v->value_length;
+  if (v->value_length != 0)
+      p = variable_buffer_output (p, " ", 1);
+  p = variable_expand_string (p, value, (long)-1);
+
+  /* update the variable. (The variable_expand_string return is annoying!) */
+  p = strchr (p, '\0');
+  v->value = variable_buffer;
+  v->value_length = p - v->value;
+  v->value_alloc_len = variable_buffer_length;
+
+  /* restore the variable buffer. */
+  variable_buffer = saved_buffer;
+  variable_buffer_length = saved_buffer_length;
+}
+#endif /* CONFIG_WITH_VALUE_LENGTH */
 
 static char *

trunk/src/gmake/function.c

@@ -36 +36 @@
 #endif
 
-#ifdef KMK
+#ifdef KMK_HELPERS
 # include "kbuild.h"
 #endif 
@@ -887 +887 @@
       char *result = 0;
 #ifdef CONFIG_WITH_VALUE_LENGTH
-      if (len > (unsigned int)var->value_length)
+      if (len >= (unsigned int)var->value_alloc_len)
         {
           free (var->value);
-          var->value = xmalloc (len + 1);
+          var->value_alloc_len = (len + 32) & ~31;
+          var->value = xmalloc (var->value_alloc_len);
         }
       memcpy (var->value, p, len);
@@ -2330 +2331 @@
   { STRING_SIZE_TUPLE("comp-vars"),     3,  3,  1,  func_comp_vars},
 #endif
-#ifdef KMK
+#ifdef KMK_HELPERS
   { STRING_SIZE_TUPLE("kb-src-tool"),   1,  1,  0,  func_kbuild_source_tool},
   { STRING_SIZE_TUPLE("kb-obj-base"),   1,  1,  0,  func_kbuild_object_base},

trunk/src/gmake/variable.c

@@ -364 +364 @@
           else
             assert (value_length == strlen (value));
-          v->value_length = value_length;
           if (!duplicate_value)
             {
@@ -370 +369 @@
                 free (v->value);
               v->value = value;
+              v->value_alloc_len = value_length + 1;
             }
           else
             {
-              v->value = xrealloc (v->value, v->value_length + 1);
-              bcopy (value, v->value, v->value_length + 1);
+              if ((unsigned int)v->value_alloc_len <= value_length)
+                {
+                  free (v->value);
+                  v->value_alloc_len = (value_length + 0x40) & ~0x3f;
+                  v->value = xmalloc (v->value_alloc_len);
+                }
+              memcpy (v->value, value, value_length + 1);
             }
+          v->value_length = value_length;
 #else
           if (v->value != 0)
@@ -408 +414 @@
   v->value_length = value_length;
   if (!duplicate_value)
-    v->value = value;
+    {
+      v->value_alloc_len = value_length + 1;
+      v->value = value;
+    }
   else
     {
-      v->value = xmalloc (v->value_length + 1);
-      bcopy (value, v->value, v->value_length + 1);
+      v->value_alloc_len = (value_length + 32) & ~31;
+      v->value = xmalloc (v->value_alloc_len);
+      memcpy (v->value, value, value_length + 1);
     }
 #else
@@ -1075 +1085 @@
 #ifdef CONFIG_WITH_VALUE_LENGTH
       v->value_length = strlen (v->value);
+      v->value_alloc_len = v->value_length + 1;
 #endif 
     }
@@ -1259 +1270 @@
   return result_0;
 }
+
+
+#ifdef CONFIG_WITH_VALUE_LENGTH
+static struct variable *
+do_variable_definition_append (const struct floc *flocp, struct variable *v, char *value, 
+                               enum Variable_origin origin)
+{
+  if (env_overrides && origin == o_env)
+    origin = o_env_override;
+
+  if (env_overrides && v->origin == o_env)
+    /* V came from in the environment.  Since it was defined
+       before the switches were parsed, it wasn't affected by -e.  */
+    v->origin = o_env_override;
+
+  /* A variable of this name is already defined.
+     If the old definition is from a stronger source
+     than this one, don't redefine it.  */
+  if ((int) origin < (int) v->origin)
+    return v;
+  v->origin = origin;
+
+  /* location */
+  if (flocp != 0)
+    v->fileinfo = *flocp;
+
+  /* The juicy bits, append the specified value to the variable 
+     This is a heavily exercied code path in kBuild. */
+  if (v->recursive)
+    {
+      /* The previous definition of the variable was recursive.
+         The new value is the unexpanded old and new values. */
+      unsigned int value_len = strlen (value);
+      unsigned int new_value_len = value_len + (v->value_length != 0 ? 1 + v->value_length : 0);
+
+      /* adjust the size. */
+      if ((unsigned)v->value_alloc_len <= new_value_len)
+        {
+          v->value_alloc_len = (new_value_len + 0x80) + 0x7f;
+          v->value = xrealloc (v->value, v->value_alloc_len);
+        }
+
+      /* insert the new bits */
+      if (v->value_length != 0)
+        {
+          v->value[v->value_length] = ' ';
+          memcpy (&v->value[v->value_length + 1], value, value_len + 1);
+        }
+      else
+          memcpy (v->value, value, value_len + 1);
+      v->value_length = new_value_len;
+    }
+  else 
+    {
+      /* The previous definition of the variable was simple.
+         The new value comes from the old value, which was expanded
+         when it was set; and from the expanded new value. */
+      append_expanded_string_to_variable(v, value);
+    }
+
+  /* update the variable */
+  return v;
+}
+#endif /* CONFIG_WITH_VALUE_LENGTH */
 
 
@@ -1335 +1410 @@
         else
           {
+#ifdef CONFIG_WITH_VALUE_LENGTH
+            v->append = append;
+            return do_variable_definition_append (flocp, v, value, origin);
+#else /* !CONFIG_WITH_VALUE_LENGTH */
+
             /* Paste the old and new values together in VALUE.  */
 
@@ -1341 +1421 @@
 
             val = value;
-#ifdef CONFIG_WITH_VALUE_LENGTH
-            if (v->recursive)
-              {
-                /* The previous definition of the variable was recursive.
-                   The new value is the unexpanded old and new values. */
-                flavor = f_recursive;
-                oldlen = v->value_length; assert (oldlen == strlen (v->value));
-                vallen = strlen (val);
-
-                value_len = oldlen + 1 + vallen;
-                p = alloc_value = xmalloc (value_len + 1);
-                memcpy (p, v->value, oldlen);
-                p[oldlen] = ' ';
-                memcpy (&p[oldlen + 1], val, vallen + 1);
-              }
-            else 
-              {
-                /* The previous definition of the variable was simple.
-                   The new value comes from the old value, which was expanded
-                   when it was set; and from the expanded new value.  Allocate
-                   memory for the expansion as we may still need the rest of the
-                   buffer if we're looking at a target-specific variable.  */
-                char *buf;
-                unsigned int len;
-                install_variable_buffer (&buf, &len);
-
-                p = variable_buffer;
-                if ( v->value && *v->value )
-                  {
-                    p = variable_buffer_output (p, v->value, v->value_length);
-                    p = variable_buffer_output (p, " ", 1);
-                  }
-                p = variable_expand_string (p, val, (long)-1);
-
-                p = strchr (p, '\0'); /* returns adjusted start, not end. */
-                alloc_value = variable_buffer;
-                value_len = p - alloc_value;
-                p = alloc_value;
-
-                variable_buffer = NULL; /* hackish */
-                restore_variable_buffer (buf, len);
-              }
-#else /* !CONFIG_WITH_VALUE_LENGTH */
             if (v->recursive)
               /* The previous definition of the variable was recursive.
@@ -1643 +1680 @@
   v->value = p;
 #ifdef CONFIG_WITH_VALUE_LENGTH
-  v->value_length = -1;
+  v->value_length = v->value_alloc_len = -1;
 #endif 
 

trunk/src/gmake/variable.h

@@ -59 +59 @@
 #ifdef CONFIG_WITH_VALUE_LENGTH
     int value_length;           /* The length of the value, usually unused.  */
+    int value_alloc_len;        /* The amount of memory we've actually allocated. */
+    /* FIXME: make lengths unsigned! */
 #endif 
     char *value;                /* Variable value.  */
@@ -128 +130 @@
 extern void install_variable_buffer PARAMS ((char **bufp, unsigned int *lenp));
 extern void restore_variable_buffer PARAMS ((char *buf, unsigned int len));
+#ifdef CONFIG_WITH_VALUE_LENGTH
+extern void append_expanded_string_to_variable PARAMS ((struct variable *v, char *value));
+#endif
 
 /* function.c */