ACE/examples/Shared_Malloc/test_persistence.cpp

   1 // Test the persistence capabilities of <ACE_Malloc> when configured
   2 // for mmap-based shared memory management.
   3
   4 // This examples uses scanf to read user inputs from stdin into fixed
   5 // sized buffers.  This may cause buffers to overrun.
   6
   7 #include "ace/OS_NS_string.h"
   8 #include "ace/Malloc_T.h"
   9 #include "ace/MMAP_Memory_Pool.h"
  10 #include "ace/Lib_Find.h"
  11
  12 // FUZZ: disable check_for_streams_include
  13 #include "ace/streams.h"
  14
  15 #include "ace/Null_Mutex.h"
  16
  17 typedef ACE_Malloc <ACE_MMAP_MEMORY_POOL, ACE_Null_Mutex> TEST_MALLOC;
  18 typedef ACE_Malloc_LIFO_Iterator <ACE_MMAP_MEMORY_POOL, ACE_Null_Mutex> MALLOC_LIFO_ITERATOR;
  19 typedef ACE_Malloc_FIFO_Iterator <ACE_MMAP_MEMORY_POOL, ACE_Null_Mutex> MALLOC_FIFO_ITERATOR;
  20
  21 // Shared memory manager.
  22 static TEST_MALLOC *shmem_allocator = 0;
  23
  24 // Backing store name.
  25 static ACE_TCHAR backing_store[MAXPATHLEN + 1] = ACE_TEXT ("");
  26
  27 class Employee
  28 {
  29 public:
  30   Employee () : name_ (0), id_ (0) {}
  31
  32   Employee (const char *name, u_long id) : id_ (id)
  33   {
  34     size_t len = ACE_OS::strlen (name) + 1;
  35     this->name_ = reinterpret_cast<char *> (shmem_allocator->malloc (len));
  36     ACE_OS::strcpy (this->name_, name);
  37   }
  38
  39   ~Employee () { shmem_allocator->free (this->name_); }
  40
  41   const char *name () const { return this->name_; }
  42
  43   void name (const char *name)
  44   {
  45     if (this->name_)
  46       shmem_allocator->free (this->name_);
  47
  48     size_t len = ACE_OS::strlen (name) + 1;
  49     this->name_ = reinterpret_cast<char *> (shmem_allocator->malloc (len));
  50     ACE_OS::strcpy (this->name_, name);
  51   }
  52
  53   u_long id () const { return id_; }
  54
  55   void id (u_long id) { id_ = id; }
  56
  57   void *operator new (size_t)
  58   {
  59     return shmem_allocator->malloc (sizeof (Employee));
  60   }
  61
  62   void *operator new (size_t, const std::nothrow_t&)
  63   {
  64     return shmem_allocator->malloc (sizeof (Employee));
  65   }
  66   void operator delete (void *p, const std::nothrow_t&) noexcept
  67   {
  68     shmem_allocator->free (p);
  69   }
  70
  71   void operator delete (void *pointer)
  72   {
  73     shmem_allocator->free (pointer);
  74   }
  75
  76 private:
  77   char *name_;
  78   // Employee name.
  79
  80   u_long id_;
  81   // Employee ID.
  82 };
  83
  84 class GUI_Handler
  85 {
  86 public:
  87   GUI_Handler () { menu (); }
  88
  89   ~GUI_Handler ()
  90   {
  91     TEST_MALLOC::MEMORY_POOL &pool =
  92       shmem_allocator->memory_pool ();
  93     pool.sync ();
  94   }
  95
  96   int service()
  97   {
  98     char option[BUFSIZ];
  99     char buf1[BUFSIZ];
 100     char buf2[BUFSIZ];
 101
 102     if (::scanf ("%s", option) <= 0)
 103       {
 104         ACE_ERROR ((LM_ERROR,
 105                     "try again\n"));
 106         return 0;
 107       }
 108
 109     int result = 0;
 110     switch (option[0])
 111       {
 112       case 'I' :
 113       case 'i' :
 114         if (::scanf ("%s %s", buf1, buf2) <= 0)
 115           break;
 116         result = insert_employee (buf1,
 117                                   ACE_OS::atoi (buf2));
 118         break;
 119       case 'F' :
 120       case 'f' :
 121         if (::scanf ("%s", buf1) <= 0)
 122           break;
 123         result = find_employee (buf1);
 124         break;
 125       case 'D' :
 126       case 'd' :
 127         if (::scanf ("%s", buf1) <= 0)
 128           break;
 129         result = delete_employee (buf1);
 130         break;
 131       case 'L' :
 132       case 'l' :
 133         result = list_employees ();
 134         break;
 135       case 'Q' :
 136       case 'q' :
 137         return -1;
 138         ACE_NOTREACHED(break);
 139       default :
 140         cout << "unrecognized command" << endl;
 141       }
 142     if (result == 0)
 143       cout << "Last operation was successful!!" << endl;
 144     else
 145       cout << "Last operation failed!! " << endl;
 146
 147     menu ();
 148
 149     return 0;
 150   }
 151
 152   void menu()
 153   {
 154     cout << endl;
 155     cout << "\t**************************                                  " << endl;
 156     cout << "\tThe employee database menu                                  " << endl;
 157     cout << endl;
 158     cout << "\t<I> Insert    <name>   <id>                                 " << endl;
 159     cout << "\t<D> Delete    <name>                                        " << endl;
 160     cout << "\t<F> Find      <name>                                        " << endl;
 161     cout << endl;
 162     cout << "\t<L> List all employees                                      " << endl;
 163     cout << endl;
 164     cout << "\t<Q> Quit " << endl;
 165     cout << "\t**************************                                  " << endl;
 166   }
 167
 168 private:
 169   int insert_employee (const char *name,
 170                        u_long id);
 171   int find_employee (const char *name);
 172   int list_employees ();
 173   int delete_employee (const char *name);
 174 };
 175
 176 int
 177 GUI_Handler::insert_employee (const char *name,
 178                               u_long id)
 179 {
 180   if (find_employee (name) == 0)
 181     ACE_ERROR_RETURN ((LM_ERROR,
 182                        "Employee already exists\n"),
 183                       -1);
 184
 185   Employee *new_employee = 0;
 186
 187   ACE_NEW_RETURN (new_employee,
 188                   Employee (name, id),
 189                   -1);
 190
 191   if (shmem_allocator->bind (name,
 192                              new_employee) == -1)
 193     ACE_ERROR_RETURN ((LM_ERROR,
 194                        "bind failed\n"),
 195                       -1);
 196   return 0;
 197 }
 198
 199 int
 200 GUI_Handler::find_employee (const char *name)
 201 {
 202   void *temp = 0;
 203
 204   if (shmem_allocator->find (name,
 205                              temp) == 0)
 206     {
 207       Employee *employee = reinterpret_cast<Employee *> (temp);
 208
 209       ACE_DEBUG ((LM_DEBUG,
 210                   "The following employee was found.......\n\n"));
 211       ACE_DEBUG ((LM_DEBUG,
 212                   "Employee name: %s\nEmployee id:   %d\n",
 213                   employee->name (),
 214                   employee->id ()));
 215       return 0;
 216     }
 217
 218   return -1;
 219 }
 220
 221 int
 222 GUI_Handler::list_employees ()
 223 {
 224   ACE_DEBUG ((LM_DEBUG,
 225               "The following employees were found.......\n\n"));
 226
 227   {
 228     ACE_DEBUG ((LM_DEBUG,
 229                 "LIFO order:\n"));
 230     MALLOC_LIFO_ITERATOR iterator (*shmem_allocator);
 231
 232     for (void *temp = 0;
 233          iterator.next (temp) != 0;
 234          iterator.advance ())
 235       {
 236         Employee *employee = reinterpret_cast<Employee *> (temp);
 237         ACE_DEBUG ((LM_DEBUG,
 238                     "Employee name: %s\nEmployee id:   %d\n",
 239                     employee->name (),
 240                     employee->id ()));
 241       }
 242   }
 243
 244   {
 245     ACE_DEBUG ((LM_DEBUG,
 246                 "FIFO order:\n"));
 247     MALLOC_FIFO_ITERATOR iterator (*shmem_allocator);
 248
 249     for (void *temp = 0;
 250          iterator.next (temp) != 0;
 251          iterator.advance ())
 252       {
 253         Employee *employee = reinterpret_cast<Employee *> (temp);
 254         ACE_DEBUG ((LM_DEBUG,
 255                     "Employee name: %s\nEmployee id:   %d\n",
 256                     employee->name (),
 257                     employee->id ()));
 258       }
 259   }
 260   return 0;
 261 }
 262
 263 int
 264 GUI_Handler::delete_employee (const char *name)
 265 {
 266   void *temp = 0;
 267
 268   if (shmem_allocator->unbind (name,
 269                                temp) == 0)
 270     {
 271       Employee *employee = reinterpret_cast<Employee *> (temp);
 272
 273       ACE_DEBUG ((LM_DEBUG,
 274                   "The following employee was found and deleted.......\n\n"));
 275
 276       ACE_DEBUG ((LM_DEBUG,
 277                   "Employee name: %s\nEmployee id:   %d\n",
 278                   employee->name (),
 279                   employee->id ()));
 280
 281       delete employee;
 282       return 0;
 283     }
 284
 285   ACE_DEBUG ((LM_DEBUG,
 286               "There is no employee with name %s",
 287               name));
 288   return -1;
 289 }
 290
 291 void
 292 parse_args (int argc, ACE_TCHAR *argv[])
 293 {
 294   if (argc > 1)
 295     ACE_OS::strcpy (backing_store, argv[1]);
 296 }
 297
 298 int
 299 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 300 {
 301   parse_args (argc, argv);
 302
 303   if (ACE_OS::strcmp (backing_store, ACE_TEXT ("")) == 0)
 304     {
 305 #if defined (ACE_DEFAULT_BACKING_STORE)
 306       // Create a temporary file.
 307       ACE_OS::strcpy (backing_store,
 308                       ACE_DEFAULT_BACKING_STORE);
 309 #else /* ACE_DEFAULT_BACKING_STORE */
 310       if (ACE::get_temp_dir (backing_store,
 311                              MAXPATHLEN - 17) == -1) // -17 for ace-malloc-XXXXXX
 312         {
 313           ACE_ERROR ((LM_ERROR,
 314                       ACE_TEXT ("Temporary path too long, ")
 315                       ACE_TEXT ("defaulting to current directory\n")));
 316           backing_store[0] = 0;
 317         }
 318
 319       // Add the filename to the end
 320       ACE_OS::strcat (backing_store, ACE_TEXT ("ace-malloc-XXXXXX"));
 321
 322 #endif /* ACE_DEFAULT_BACKING_STORE */
 323     }
 324
 325   ACE_NEW_RETURN (shmem_allocator,
 326                   TEST_MALLOC (backing_store),
 327                   -1);
 328
 329   GUI_Handler handler;
 330
 331   for (;;)
 332     if (handler.service () == -1)
 333       {
 334         ACE_DEBUG ((LM_DEBUG,
 335                     ACE_TEXT ("closing down ....\n")));
 336         break;
 337       }
 338
 339   return 0;
 340 }
 341