Changeset 2503 for trunk/src/win32k/misc/heaptest.c

Timestamp:

Jan 23, 2000, 4:20:53 AM (26 years ago)

Author:

bird

Message:

Initial resident heap coding completed.
The AVL heap is seems to be much faster; it uses 40% of the time that the
traditional linked-list based heap is using when executing the heaptest.

File:

• trunk/src/win32k/misc/heaptest.c (modified) (16 diffs)

trunk/src/win32k/misc/heaptest.c

@@ -1 @@
-/* $Id: heaptest.c,v 1.1 2000-01-22 18:21:03 bird Exp $
+/* $Id: heaptest.c,v 1.2 2000-01-23 03:20:52 bird Exp $
  *
  * Test of resident and swappable heaps.
@@ -13 +13 @@
 *   Defined Constants
 *******************************************************************************/
-#define NUMBER_OF_POINTERS      10240
-#define RANDOMTEST_ITERATIONS   10240
+#define NUMBER_OF_POINTERS      16384
+#define RANDOMTEST_ITERATIONS   65536*2
+#define Int3()          __interrupt(3)
 
 
@@ -22 +23 @@
 #include "malloc.h"
 #include "rmalloc.h"
+#include "macros.h"
 #include <stdio.h>
 #include <stdlib.h>
+#include <memory.h>
+#include <builtin.h>
 
 
@@ -36 +40 @@
     unsigned      crmalloc;
     unsigned      crfree;
-
+    unsigned      crealloc;
     int           i;
 
@@ -54 +58 @@
  *
  */
+#if 1
     /*
      * Simple allocation test.
@@ -62 +67 @@
         {
             acb[i] = rand();
-        } while(acb[i] == 0 || acb[i] > 64);
-
+        } while(acb[i] == 0 || acb[i] > 127);
+
+        if ((i % (NUMBER_OF_POINTERS/3)) == 1)
+            acb[i] += 1024*260;
         apv[i] = rmalloc(acb[i]);
         if (apv[i] == NULL)
@@ -71 +78 @@
                 break;
         }
+        memset(apv[i], 0xA, MIN(acb[i],16));
         cb += acb[i];
     }
@@ -83 +91 @@
     {
         int cb = _res_msize(apv[i]);
-        if (cb != ((acb[i] + 3) & ~3) && (cb < ((acb[i] + 3) & ~3) || cb > 40 + ((acb[i] + 3) & ~3)) )
+        if (cb != ((acb[i] + 3) & ~3) && (cb < ((acb[i] + 3) & ~3) || cb > 52 + ((acb[i] + 3) & ~3)) )
             printf("size of avp[%d] (%d) != acb[%] (%d)\n", i, cb, i, acb[i]);
         rfree(apv[i]);
@@ -101 +109 @@
     printf("\n_res_dump_subheaps:\n");
     _res_dump_subheaps();
+#endif
 
 
@@ -115 +124 @@
     crfree = 0;
     crmalloc = 0;
+    crealloc = 0;
     while (i++ < RANDOMTEST_ITERATIONS || cAllocations > 0)
     {
@@ -120 +130 @@
         j = rand();
         if (cAllocations + (NUMBER_OF_POINTERS/20) < NUMBER_OF_POINTERS &&
-            (i < RANDOMTEST_ITERATIONS*1/4 ? (j % 8) > 1 :
-             i < RANDOMTEST_ITERATIONS*2/4 ? (j % 8) > 2 :
-             i < RANDOMTEST_ITERATIONS*3/4 ? (j % 8) > 3 :
+            (i < RANDOMTEST_ITERATIONS*1/4 ? (j % 8) > 2 :
+             i < RANDOMTEST_ITERATIONS*2/4 ? (j % 8) > 3 :
+             i < RANDOMTEST_ITERATIONS*3/4 ? (j % 8) > 4 :
              i < RANDOMTEST_ITERATIONS     ? (j % 8) > 5 : 0
              )
@@ -134 +144 @@
                 {
                     acb[j] = rand();
-                } while (acb[j] == 0 || acb[j] > 2048);
+                } while (acb[j] == 0 || (acb[j] > 2048 && (i % 11) != 10));
+                if ((i % (RANDOMTEST_ITERATIONS/20)) == 1)
+                    acb[j] += 1024*256;
                 apv[j] = rmalloc(acb[j]);
                 if (apv[j] == NULL)
@@ -141 +153 @@
                     if (acb[j] > 10000)
                         continue;
-                }
+                    break;
+                }
+                memset(apv[j], 0xA, MIN(acb[j],16));
                 cAllocations++;
                 cb += acb[j];
@@ -148 +162 @@
         }
         else
-        { /* free */
+        { /* free or realloc */
             if (cAllocations == 0)
                 continue;
+
             if (cAllocations < NUMBER_OF_POINTERS/10)
             {
@@ -162 +177 @@
                 {
                     j = rand();
-                } while (k < NUMBER_OF_POINTERS/2 && (j >= NUMBER_OF_POINTERS || apv[j] == NULL));
+                } while (k++ < NUMBER_OF_POINTERS/2 && (j >= NUMBER_OF_POINTERS || apv[j] == NULL));
                 if (k >= NUMBER_OF_POINTERS/2)
                 {
@@ -173 +188 @@
             {
                 int cb = _res_msize(apv[j]);
-                if (cb != ((acb[j] + 3) & ~3) && (cb < ((acb[j] + 3) & ~3) || cb > 40 + ((acb[j] + 3) & ~3)) )
+                if (cb != ((acb[j] + 3) & ~3) && (cb < ((acb[j] + 3) & ~3) || cb > 52 + ((acb[j] + 3) & ~3)) )
                     printf("size of avp[%d] (%d) != acb[%d] (%d)\n", j, cb, j, acb[j]);
-                rfree(apv[j]);
-                apv[j] = NULL;
-                cAllocations--;
-                crfree++;
+                if (i < RANDOMTEST_ITERATIONS*3/4 && j % 3 == 0)
+                {   /* realloc */
+                    int cb;
+                    void *pv;
+                    crealloc++;
+                    do
+                    {
+                        cb = rand();
+                    } while (cb == 0 || cb > 3072);
+                    /*
+                    if (i >= 0x1c14)
+                        Int3();
+                    */
+                    pv = rrealloc(apv[j], cb);
+                    if (pv == NULL)
+                    {
+                        printf("realloc(apv[%d](0x%08), %d) failed\n", j, apv[j], cb);
+                        continue;
+                    }
+                    apv[j] = pv;
+                    acb[j] = cb;
+                }
+                else
+                {   /* free */
+                    rfree(apv[j]);
+                    apv[j] = NULL;
+                    cAllocations--;
+                    crfree++;
+                }
             }
         }
-        _res_heap_check();
-        if (RANDOMTEST_ITERATIONS == i*2)
+        /*_res_heap_check();*/
+        if (RANDOMTEST_ITERATIONS/2 == i)
             _res_dump_subheaps();
-    }
-
-    printf("cb=%d crfree=%d crmalloc=%d\n", cb, crfree, crmalloc);
+        if ((i % 2048) == 0)
+            printf("i=%d cAllocations=%d\n", i, cAllocations);
+    }
+
+    printf("cb=%d crfree=%d crmalloc=%d crealloc=%d\n", cb, crfree, crmalloc, crealloc);
 
     printf("_res_dump_subheaps:\n");