ACE/tests/Cached_Allocator_Test.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Cached_Allocator_Test.cpp
   5  *
   6  *  Simple test of ACE_Dynamic_Cached_Allocator and ACE_Cached_Allocator.
   7  *
   8  *  @author Jaroslaw Nozderko <jareknz@polbox.com>
   9  */
  10 //=============================================================================
  11
  12
  13 #include "test_config.h"
  14 #include "ace/OS_NS_string.h"
  15 #include "ace/Malloc_T.h"
  16 #include "ace/High_Res_Timer.h"
  17
  18
  19
  20 #include "ace/Synch_Traits.h"
  21 #include "ace/Null_Mutex.h"
  22
  23 typedef ACE_Dynamic_Cached_Allocator<ACE_SYNCH_NULL_MUTEX> DYNAMIC_ALLOCATOR;
  24
  25 static int
  26 speed_test (ACE_UINT32 loops)
  27 {
  28   double tt    = 0.0,
  29     ut    = 0.0,
  30     utus  = 0.0,
  31     speed = 0.0;
  32
  33   ACE_Time_Value tc;
  34   void *ptr = 0;
  35   ACE_UINT32 i = loops;
  36   size_t n_chunks = 10;
  37   size_t chunk_size = 8;
  38
  39   ACE_DEBUG ((LM_INFO,
  40               ACE_TEXT (" (%t) ACE_Dynamic_Cached_Allocator ")
  41               ACE_TEXT ("speed test...\n")));
  42
  43   DYNAMIC_ALLOCATOR allocator (n_chunks, chunk_size);
  44
  45   ACE_High_Res_Timer timer;
  46   timer.reset ();
  47
  48   timer.start ();
  49
  50   while (i--)
  51     {
  52       ptr = allocator.malloc (chunk_size);
  53       allocator.free (ptr);
  54     }
  55
  56   timer.stop ();
  57
  58   timer.elapsed_time (tc);
  59
  60   ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Iterations : %d\n"), loops));
  61   tt    = tc.sec () + tc.usec ()*1.0e-6;
  62   ut    = tt/loops;
  63   utus  = ut*1.0e6;
  64   speed = loops/tt;
  65
  66   ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Total time : %.6g [s]\n"), tt));
  67   ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Unit time  : %.6g [us]\n"), utus));
  68   ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Speed      : %.6g [1/s]\n"), speed));
  69
  70   return 0;
  71 }
  72
  73 typedef char MEMBLOCK[8];
  74 typedef ACE_Cached_Allocator<MEMBLOCK, ACE_SYNCH_NULL_MUTEX> STATIC_ALLOCATOR;
  75
  76 static int
  77 stdspeed_test (ACE_UINT32 loops)
  78 {
  79
  80   double tt    = 0.0,
  81     ut    = 0.0,
  82     utus  = 0.0,
  83     speed = 0.0;
  84
  85   ACE_Time_Value tc;
  86   void *ptr = 0;
  87   ACE_UINT32 i = loops;
  88   size_t n_chunks   = 10,
  89     chunk_size = 8;
  90
  91   ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) ACE_Cached_Allocator ")
  92                        ACE_TEXT ("speed test...\n")));
  93
  94   STATIC_ALLOCATOR allocator (n_chunks);
  95
  96   ACE_High_Res_Timer timer;
  97   timer.reset ();
  98
  99   timer.start ();
 100   while (i--)
 101     {
 102       ptr = allocator.malloc (chunk_size);
 103       allocator.free (ptr);
 104     }
 105   timer.stop ();
 106
 107   timer.elapsed_time (tc);
 108
 109   ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Iterations : %d\n"), loops));
 110   tt    = tc.sec () + tc.usec ()*1.0e-6;
 111   ut    = tt/loops;
 112   utus  = ut*1.0e6;
 113   speed = loops/tt;
 114
 115   ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Total time : %.6g [s]\n"), tt));
 116   ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Unit time  : %.6g [us]\n"), utus));
 117   ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Speed      : %.6g [1/s]\n"), speed));
 118
 119   return 0;
 120 }
 121
 122 int
 123 run_main (int argc, ACE_TCHAR *argv[])
 124 {
 125   ACE_START_TEST (ACE_TEXT ("Cached_Allocator_Test"));
 126
 127   size_t chunk_size = 0;
 128   size_t n_chunks   = 0;
 129   size_t requested_size = 0;
 130   size_t depth = 0;
 131   char *ptr1 = 0;
 132   char *ptr2 = 0;
 133   char *ptr3 = 0;
 134   char *ptr4 = 0;
 135   ACE_UINT32 loops = 0;
 136
 137   const char *str1 = "12345678";
 138   const char *str3 = "ABCDEFGH";
 139
 140   if (argc < 2)
 141     loops = 10000000;
 142   else
 143     loops = ACE_OS::atoi (argv[1]);
 144
 145   n_chunks = 2;
 146
 147   for (chunk_size = 1; chunk_size <= 9; ++chunk_size) // 9 is strlen(str1 or str2) + 1
 148     {
 149       ACE_DEBUG ((LM_INFO,
 150                   ACE_TEXT (" (%t) Creating allocator: ")
 151                   ACE_TEXT ("%B chunks, %B bytes each\n"),
 152                   n_chunks,
 153                   chunk_size));
 154
 155       DYNAMIC_ALLOCATOR allocator (n_chunks, chunk_size);
 156
 157       if ((depth = allocator.pool_depth ()) != n_chunks)
 158         ACE_ERROR ((LM_ERROR,
 159                     ACE_TEXT ("Expected pool depth %B but reported %B\n"),
 160                     n_chunks, depth));
 161       requested_size = chunk_size;
 162       ACE_DEBUG ((LM_INFO,
 163                   ACE_TEXT (" (%t) Allocating chunk 1: %B bytes, should succeed...\n"),
 164                   requested_size));
 165
 166       ptr1 = (char *) allocator.malloc (requested_size);
 167       if (!ptr1)
 168         ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT (" (%t) Failed, exiting.\n")), -1);
 169
 170       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) OK, succeeded.\n")));
 171       if ((depth = allocator.pool_depth ()) != (n_chunks - 1))
 172         ACE_ERROR ((LM_ERROR,
 173                     ACE_TEXT ("Expected pool depth %B but reported %B\n"),
 174                     n_chunks - 1, depth));
 175
 176       requested_size = chunk_size + 1;
 177       ACE_DEBUG ((LM_INFO,
 178                   ACE_TEXT (" (%t) Allocating chunk 2: %B bytes, too big, should fail...\n"),
 179                   requested_size));
 180
 181       ptr2 = (char *) allocator.malloc (requested_size);
 182       if (!ptr2)
 183         ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) OK, failed.\n")));
 184       else
 185         ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT (" (%t) Something is wrong...\n")), -1);
 186
 187       requested_size = chunk_size - 1;
 188       ACE_DEBUG ((LM_INFO,
 189                   ACE_TEXT (" (%t) Allocating chunk 3: %B bytes, ")
 190                   ACE_TEXT ("should succeed...\n"),
 191                   requested_size));
 192       ptr3 = (char *) allocator.malloc (requested_size);
 193       if (!ptr3)
 194         ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT (" (%t) Failed, exiting.\n")), -1);
 195
 196       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) OK, succeeded.\n")));
 197
 198       // One chunk too far...
 199       if ((depth = allocator.pool_depth ()) != 0)
 200         ACE_ERROR ((LM_ERROR,
 201                     ACE_TEXT ("Expected pool depth 0 but reported %B\n"),
 202                     depth));
 203       requested_size = chunk_size;
 204       ACE_DEBUG ((LM_INFO,
 205                   ACE_TEXT (" (%t) Allocating chunk 4: %B bytes, no free chunks,")
 206                   ACE_TEXT (" should fail...\n"),
 207                   requested_size));
 208
 209       ptr4 = (char *) allocator.malloc (requested_size);
 210       if (!ptr4)
 211         ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) OK, failed.\n")));
 212       else
 213         ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT (" (%t) Something is wrong\n")), -1);
 214
 215       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Writing to chunk 1:   %C\n"), str1));
 216       ACE_OS::memcpy (ptr1, str1, chunk_size);
 217       ptr1[chunk_size - 1] = '\0';
 218       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Reading from chunk 1: %C\n"), ptr1));
 219
 220       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Writing to chunk 3:   %C\n"), str3));
 221       ACE_OS::memcpy (ptr3, str3, chunk_size);
 222       ptr3[chunk_size - 1] = '\0';
 223       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Reading from chunk 3: %C\n"), ptr3));
 224
 225       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Deallocating chunk 1\n")));
 226       allocator.free (ptr1);
 227
 228       requested_size = chunk_size;
 229       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Allocating chunk: %B bytes, ")
 230                   ACE_TEXT ("should succeed...\n"),
 231                   requested_size));
 232       ptr1 = (char *) allocator.malloc (requested_size);
 233       if (!ptr1)
 234         ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT (" (%t) Failed, exiting.\n")), -1);
 235
 236       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) OK, succeeded.\n")));
 237
 238       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Deallocating chunk 1\n")));
 239       allocator.free (ptr1);
 240       ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Deallocating chunk 3\n")));
 241       allocator.free (ptr3);
 242     }
 243
 244   speed_test (loops);
 245   stdspeed_test (loops);
 246
 247   ACE_END_TEST;
 248   return 0;
 249 }
 250