the share memory of Apache

小木木

Some knowledge about apr_share_memory
First, I will give a small example to show what is apr_share_memory :
/ *pseudo code about the whole progress* /
#include
#include

#include
#include
#include
#include
#include
#include

Read();
Write();

int main()
{
       apr_shm_t *shm = NULL;
       apr_pool_t *pool = NULL;
       const char *filename = "ab.txt";
       apr_status_t rv;
       char *buf = NULL;

       apr_initialize();
      
       apr_pool_create(&pool,NULL);
     
       if(rv = apr_shm_create(&shm,1024,filename,pool) != APR_SUCCESS)
       {
           printf("%d!\n",rv);
              return rv;
       }
      
       if(rv = apr_shm_attach(&shm,NULL,pool) != APR_SUCCESS)
       {
              printf("attach faild\n");
              return rv;
       }
     
       //Read();
         Write();

       if(rv = apr_shm_detach(shm) != APR_SUCCESS)
       {
              printf("detach failed\n");
              return rv;
       }

       printf("the whole progress success!\n");
      
       apr_terminate();

       return 0;
      
}

Now,to present the major function in the example:
1)      apr_initialize()  
   This is called skeleton code, we call apr_initialize() at the initialization.

2)      apr_pool_create()
       the prototype:
/**
      * Create a new pool.
      * @param newpool The pool we have just created.
* @param parent The parent pool.  If this is NULL, the new pool is a root
*        pool.  If it is non-NULL, the new pool will inherit all
*        of its parent pool's attributes, except the apr_pool_t will
      *        be a sub-pool.
   */
APR_DECLARE(apr_status_t) apr_pool_create(apr_pool_t **newpool, apr_pool_t *parent);

3)      apr_shm_create();
the prototype:
/**
* Create and make accessable a shared memory segment.
* @param m The shared memory structure to create.
* @param reqsize The desired size of the segment.
* @param filename The file to use for shared memory on platforms that
*        require it.
* @param pool the pool from which to allocate the shared memory
*        structure.
* @remark A note about Anonymous vs. Named shared memory segments:
*         Not all plaforms support anonymous shared memory segments, but in
*         some cases it is prefered over other types of shared memory
*         implementations. Passing a NULL 'file' parameter to this function
*         will cause the subsystem to use anonymous shared memory segments.
*         If such a system is not available, APR_ENOTIMPL is returned.
* @remark A note about allocation sizes:
*         On some platforms it is necessary to store some metainformation
*         about the segment within the actual segment. In order to supply
*         the caller with the requested size it may be necessary for the
*         implementation to request a slightly greater segment length
*         from the subsystem. In all cases, the apr_shm_baseaddr_get()
*         function will return the first usable byte of memory.
*
*/
APR_DECLARE(apr_status_t) apr_shm_create(apr_shm_t **m,
                                         apr_size_t reqsize,
                                         const char *filename,
                                         apr_pool_t *pool);
4) apr_shm_attach();
the prototype:
/**
* Attach to a shared memory segment that was created
* by another process.
* @param m The shared memory structure to create.
* @param filename The file used to create the original segment.
*        (This MUST match the original filename.)
* @param pool the pool from which to allocate the shared memory
*        structure for this process.
*/
APR_DECLARE(apr_status_t) apr_shm_attach(apr_shm_t **m,
                                         const char *filename,
                                         apr_pool_t *pool);

5) apr_shm_detach();
the prototype:
/**
* Detach from a shared memory segment without destroying it.
* @param m The shared memory structure representing the segment
*        to detach from.
*/
APR_DECLARE(apr_status_t) apr_shm_detach(apr_shm_t *m);

6) apr_terminate();
As the apr_initialization ,we call apr_terminate() at the finalization


In addition:
This is another function which is apr_shm_destory()
/**
* Destroy a shared memory segment and associated memory.
* @param m The shared memory segment structure to destroy.
*/
APR_DECLARE(apr_status_t) apr_shm_destroy(apr_shm_t *m);

As we know, maybe it’s simple for us to use the function, but how the function work and why it works like this, we have to read and think the code. It’s a long way to master the apr_share_momory.