ACE Tutorial 021
Pooling your memories

The client side is a little simpler than the server. Mainly because we don't try to delete the pool:

- Create an Allocator to access the pool
- Find the named region

    // page03.html,v 1.8 2000/03/19 20:09:34 jcej Exp

    #include "mpool.h"

    #if defined(ACE_LACKS_SYSV_SHMEM)
    int
    main (int, char *[])
    {
      ACE_ERROR_RETURN ((LM_ERROR,
                         "System V Semaphores not available on this platform.\n"),100);
    }
    #else // ACE_LACKS_SYSV_SHMEM
    int
    main (int, char *[])
    {
      /*
        Use the same pool name used by the server when we create our
        Allocator.  This assures us that we don't create a whole new
        pool.
        */
      Allocator allocator (Constants::PoolName);

      /*
        You can put anything in the memory pool.  Not just the
        character array we want.  The find() method till, therefore,
        return a void* that we will have to cast.
        */
      void *region;

      /*
        We use find() to locate a named region in the pool.  This is
        the counterpart to bind() used in the server.
        Here, we go try to find the region that the server has created
        and filled with data.  If there was a problem getting the pool
        or finding the region, we'll get back -1 from find().
        */
      if (allocator.pool ().find (Constants::RegionName,region) == -1)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "Cannot find the name '%s'\n",
                           Constants::RegionName),
                          100);

      /*
        Since find() returns us a void*, we cast it here to the char*
        that we want.
        */
      char *shm = (char *) region;

      ACE_DEBUG ((LM_INFO,
                  "Shared memory is at 0x%x\n",
                  shm));

      /*
        The same pair of semaphores as used by the server are created
        here.  We probably don't need the CREATE flag since the server
        should have already done that.  There may be some very small
        windows, however, where the server would have created the
        memory pool but not yet gotten to the semaphores.
        */
      ACE_SV_Semaphore_Complex mutex;
      ACE_ASSERT (mutex.open (Constants::SEM_KEY_1,
                              ACE_SV_Semaphore_Complex::ACE_CREATE,
                              0) != -1);

      ACE_SV_Semaphore_Complex synch;
      ACE_ASSERT (synch.open (Constants::SEM_KEY_2,
                              ACE_SV_Semaphore_Complex::ACE_CREATE,
                              0) != -1);

      /*
        It doesn't matter if we created 'mutex' or if the server did.
        In either case, it was created in a locked state and we will
        block here until somebody unlocks it.  In our scenario, that
        will have to be the server.
        */
      if (mutex.acquire () == -1)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "(%P) client mutex.acquire"),
                          1);

      /*
        Now that we know it is safe to access the data, we'll run
        through and make sure that it contains what we think the server
        supplied.
        */
      for (int i = 0; i < Constants::SHMSZ; i++)
        ACE_ASSERT (Constants::SHMDATA[i] == shm[i]);

      /*
        Look back at the server.  After filling the region, it will
        attempt to acquire the lock on 'synch'.  It will wait there
        until we release() the semaphore.  That will allow it to remove
        the pool and cleanup.  We can simply exit once we perform the
        release. (Ok, a free() of the region would probably be polite...)
        */
      if (synch.release () == -1)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "(%P) client synch.release"),
                          1);

      return 0;
    }

    /*
      Again, we have the necessary explicit template instantiations
      because I based this on an ACE example instead of creating it from scratch.
     */
    #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
    template class ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_SV_Semaphore_Simple>;
    template class ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_SV_Semaphore_Simple, ACE_Control_Block>;
    template class ACE_Guard<ACE_SV_Semaphore_Simple>;
    template class ACE_Write_Guard<ACE_SV_Semaphore_Simple>;
    template class ACE_Read_Guard<ACE_SV_Semaphore_Simple>;
    #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
    #pragma instantiate ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_SV_Semaphore_Simple>
    #pragma instantiate ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_SV_Semaphore_Simple, ACE_Control_Block>
    #pragma instantiate ACE_Guard<ACE_SV_Semaphore_Simple>
    #pragma instantiate ACE_Write_Guard<ACE_SV_Semaphore_Simple>
    #pragma instantiate ACE_Read_Guard<ACE_SV_Semaphore_Simple>
    #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

    #endif /* ACE_LACKS_SYSV_SHMEM */

[Tutorial Index] [Continue This Tutorial]