Changeset 1863 in kBuild for trunk/src/kmk/incdep.c

Timestamp:

Oct 14, 2008 9:46:23 AM (16 years ago)

Author:

bird

Message:

kmk: Allocation caches for nameseq, dep and idep. next: variable.

File:

• trunk/src/kmk/incdep.c (modified) (25 diffs)

trunk/src/kmk/incdep.c

@@ -145 +145 @@
   char *file_end;
 
-  int is_worker;
+  int worker_tid;
 #ifdef PARSE_IN_WORKER
   unsigned int err_line_no;
   const char *err_msg;
-
-  struct dep *dep_start;            /* start of the current dep block. */
-  struct dep *dep_end;              /* end of the current dep block. */
 
   struct incdep_variable_in_set *recorded_variables_in_set_head;
@@ -207 +204 @@
 static struct incdep * volatile incdep_tail_done;
 
+
 /* The handles to the worker threads. */
 #ifdef HAVE_PTHREAD
 static pthread_t incdep_threads[1];
+static struct alloccache incdep_dep_caches[1];
+static struct alloccache incdep_nameseq_caches[1];
+
 #elif defined (WINDOWS32)
 static HANDLE incdep_threads[2];
+static struct alloccache incdep_dep_caches[2];
+static struct alloccache incdep_nameseq_caches[2];
+
 #elif defined (__OS2__)
 static TID incdep_threads[2];
+static struct alloccache incdep_dep_caches[2];
+static struct alloccache incdep_nameseq_caches[2];
 #endif
 static unsigned incdep_num_threads;
@@ -242 +248 @@
 
 #ifdef __APPLE__
-  if (cur && cur->is_worker)
+  if (cur && cur->worker_tid != -1)
     {
       ptr = malloc_zone_malloc (incdep_zone, size);
@@ -258 +264 @@
 }
 
+#if 0
 /* memset(malloc(sz),'\0',sz) wrapper. */
 static void *
@@ -265 +272 @@
 
 #ifdef __APPLE__
-  if (cur && cur->is_worker)
+  if (cur && cur->worker_tid != -1)
     ptr = malloc_zone_calloc (incdep_zone, size, 1);
   else
@@ -278 +285 @@
   return ptr;
 }
+#endif /* unused */
 
 /* free wrapper */
@@ -289 +297 @@
 }
 
+/* alloc a nameseq structure.  */
+struct nameseq *
+incdep_alloc_nameseq (struct incdep *cur)
+{
+  struct alloccache *cache;
+  if (cur->worker_tid != -1)
+    cache = &incdep_nameseq_caches[cur->worker_tid];
+  else
+    cache = &nameseq_cache;
+  return alloccache_calloc (cache);
+}
+
 /* alloc a dep structure. These are allocated in bunches to save time. */
 struct dep *
 incdep_alloc_dep (struct incdep *cur)
 {
-  if (cur->dep_start != cur->dep_end)
-    return cur->dep_start++;
-
-  cur->dep_start = (struct dep *)incdep_xcalloc (cur, sizeof(struct dep) * 256);
-  cur->dep_end = cur->dep_start + 256;
-  return cur->dep_start++;
-}
-
+  struct alloccache *cache;
+  if (cur->worker_tid != -1)
+    cache = &incdep_dep_caches[cur->worker_tid];
+  else
+    cache = &dep_cache;
+  return alloccache_calloc (cache);
+}
+
+/* grow a cache. */
+static void *
+incdep_cache_allocator (void *thrd, unsigned int size)
+{
+  (void)thrd;
+#ifdef __APPLE__
+  return malloc_zone_malloc (incdep_zone, size);
+#else
+  return xmalloc (size);
+#endif
+}
 
 /* acquires the lock */
@@ -472 +503 @@
 /* A worker thread. */
 void
-incdep_worker (void)
-{
-#ifdef PARSE_IN_WORKER
-  struct dep *dep_start = NULL;
-  struct dep *dep_end = NULL;
-#endif
-
+incdep_worker (int thrd)
+{
   incdep_lock ();
 
@@ -500 +526 @@
 
       incdep_unlock ();
-      cur->is_worker = 1;
+      cur->worker_tid = thrd;
+
       incdep_read_file (cur, NILF);
-
 #ifdef PARSE_IN_WORKER
-      cur->dep_start = dep_start;
-      cur->dep_end = dep_end;
-
       eval_include_dep_file (cur, NILF);
-
-      dep_start = cur->dep_start;
-      cur->dep_start = NULL;
-      dep_end = cur->dep_end;
-      cur->dep_end = NULL;
-#endif
-
-      cur->is_worker = 0;
+#endif
+
+      cur->worker_tid = -1;
       incdep_lock ();
 
@@ -537 +555 @@
 #ifdef HAVE_PTHREAD
 static void *
-incdep_worker_pthread (void *ignore)
-{
-  incdep_worker ();
-  (void)ignore;
+incdep_worker_pthread (void *thrd)
+{
+  incdep_worker ((size_t)thrd);
   return NULL;
 }
@@ -546 +563 @@
 #elif defined (WINDOWS32)
 static unsigned __stdcall
-incdep_worker_windows (void *ignore)
-{
-  incdep_worker ();
-  (void)ignore;
+incdep_worker_windows (void *thrd)
+{
+  incdep_worker ((size_t)thrd);
   return 0;
 }
@@ -555 +571 @@
 #elif defined (__OS2__)
 static void
-incdep_worker_os2 (void *ignore)
-{
-  incdep_worker ();
-  (void)ignore;
+incdep_worker_os2 (void *thrd)
+{
+  incdep_worker ((size_t)thrd);
 }
 #endif
@@ -633 +648 @@
   for (i = 0; i < incdep_num_threads; i++)
     {
+      alloccache_init (&incdep_dep_caches[i], sizeof(struct dep), "incdep dep",
+                       incdep_cache_allocator, (void *)i);
+      alloccache_init (&incdep_nameseq_caches[i], sizeof(struct nameseq),
+                       "incdep nameseq", incdep_cache_allocator, (void *)i);
+
 #ifdef HAVE_PTHREAD
       rc = pthread_attr_init (&attr);
@@ -641 +661 @@
       if (rc)
         fatal (f, _("pthread_attr_setdetachstate failed: err=%d"), rc);
-      rc = pthread_create (&incdep_threads[i], &attr,
-                           incdep_worker_pthread, f);
+      rc = pthread_create(&incdep_threads[i], &attr,
+                           incdep_worker_pthread, (void *)i);
       if (rc)
         fatal (f, _("pthread_mutex_init failed: err=%d"), rc);
@@ -650 +670 @@
       tid = 0;
       hThread = _beginthreadex (NULL, 128*1024, incdep_worker_windows,
-                                NULL, 0, &tid);
+                                (void *)i, 0, &tid);
       if (hThread == 0 || hThread == ~(uintptr_t)0)
         fatal (f, _("_beginthreadex failed: err=%d"), errno);
@@ -656 +676 @@
 
 #elif defined (__OS2__)
-      tid = _beginthread (incdep_worker_os2, NULL, 128*1024, NULL);
+      tid = _beginthread (incdep_worker_os2, NULL, 128*1024, (void *)i);
       if (tid <= 0)
         fatal (f, _("_beginthread failed: err=%d"), errno);
@@ -691 +711 @@
   for (i = 0; i < incdep_num_threads; i++)
     {
-      /* later? */
+      /* more later? */
+
+      alloccache_join (&dep_cache, &incdep_dep_caches[i]);
+      alloccache_join (&nameseq_cache, &incdep_nameseq_caches[i]);
     }
   incdep_num_threads = 0;
@@ -803 +826 @@
 incdep_warn (struct incdep *cur, unsigned int line_no, const char *msg)
 {
-  if (!cur->is_worker)
+  if (cur->worker_tid == -1)
     error (NILF, "%s(%d): %s", cur->name, line_no, msg);
 #ifdef PARSE_IN_WORKER
@@ -819 +842 @@
 {
   const char *ret;
-  if (!cur->is_worker)
+  if (cur->worker_tid == -1)
     {
       /* Make sure the string is terminated before we hand it to
@@ -860 +883 @@
 {
   assert (!duplicate_value);
-  if (!cur->is_worker)
+  if (cur->worker_tid == -1)
     define_variable_in_set (name, name_length, value, value_length,
                             duplicate_value, origin, recursive, set, flocp);
@@ -898 +921 @@
                             int target_var)
 {
-  if (!cur->is_worker)
+  if (cur->worker_tid == -1)
     do_variable_definition_2 (flocp, name, value, value_length, 0, value,
                               origin, flavor, target_var);
@@ -934 +957 @@
                      const struct floc *flocp)
 {
-  if (!cur->is_worker)
+  if (cur->worker_tid == -1)
     record_files (filenames, pattern, pattern_percent, deps, cmds_started,
                   commands, commands_idx, two_colon, flocp);
@@ -1329 +1352 @@
                   break;
                 }
-              filenames = incdep_xmalloc (curdep, sizeof (struct nameseq));
+              filenames = incdep_alloc_nameseq (curdep);
               memset (filenames, 0, sizeof (*filenames));
               filenames->name = incdep_record_strcache (curdep, cur, endp - cur);
@@ -1469 +1492 @@
        memcpy (cur->name, name, name_len);
        cur->name[name_len] = '\0';
-       cur->is_worker = 0;
+       cur->worker_tid = -1;
 #ifdef PARSE_IN_WORKER
        cur->err_line_no = 0;
        cur->err_msg = NULL;
-       cur->dep_start = NULL;
-       cur->dep_end = NULL;
        cur->recorded_variables_in_set_head = NULL;
        cur->recorded_variables_in_set_tail = NULL;
@@ -1491 +1512 @@
     }
 
+#ifdef ELECTRIC_HEAP
+  if (1)
+#else
   if (op == incdep_read_it)
+#endif
     {
       /* work our way thru the files directly */