httpd-modules-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Sorin Manolache" <sor...@gmail.com>
Subject Re: Load memory dyanamically using handler.
Date Wed, 10 Dec 2008 08:09:19 GMT
On Wed, Dec 10, 2008 at 06:00, Jayasingh Samuel
<jayasingh.samuel@hotmail.com> wrote:
>
>
> I have 100's of files stored in different directories and i load all these in the memory
in arrays and hash table. and i want to reload the memory automatically using some handlers.
When i do this in only the particular child thread is having the updated one and the other
request are showing me the old Datas.
>
> 1. The shared memory to store all the 100's of files in array and hash table which is
dynamically malloced and stored will be too costly also the synchronization.
> IS there any other way we can overcome this.
>
> 2. Is there any way a handler can directly access the  parent process, updating the memory
and removing the child process which has the old Data and spawning the new child process.
Can we use the mod_balancing technique of blocking the request to the server and then update
the parent and kill the child and spawn new childrens with the updated memory.
>
> Please guide me with you ideas.

Killing processes at each update is not efficient.

I would propose the following approach:

Hook post_config. This one is executed once by the parent process
before any child is spawned. Therefore, any resource opened there is
inherited by all child processes. Thus, I would create _shared_ memory
structures (see apr_shm.h, not malloc).

Beware, post_config is run every time the server configuration is
reloaded. Therefore, such shared memory structures would be created
after each config reload. In order to avoid eating up the system's
resources, you'll have to make sure that each created structure is
also destroyed. In order to do this, _register_ a function (see
apr_pool_register_cleanup) that is called when the conf pool is
destroyed. This function would destroy the shared memory structures.

Next, in child_init, _attach_ to the shared memory segment (see
apr_shm.h). From then on, the shared memory structures are shared
among all child processes. Each change is visible instantly in all
processes.

Obviously, think of synchronisation. When not every atomic change
results in a consistent state of the shared data, you'll have to
protect the shared data with mutexes. See apr_thread_mutex.h and
apr_thread_rwlock.h and maybe others. Mutexes should be created in
post_config too.

I hope this helps. You can contact me for a code sample if you want. I
don't have it handy for the moment, but I can find it.

S


-- 
A: Because it reverses the logical flow of conversation.
Q: Why is top-posting frowned upon?
A: Top-posting.
Q: What is the most annoying thing in e-mail?

Mime
View raw message