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 <stdio.h>

#include <stdlib.h>

 

#include <apr_general.h>

#include <apr_errno.h>

#include <apr_shm.h>

#include <apr_pools.h>

#include <apr_allocator.h>

#include <apr_file_io.h>

 

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.