Programming

Today, I wrote a test code for fork/execvp/waitpid. In the parent process, it fork 100 child processes which only execute "date" to print the current datetime. When any child process die, the parent process will receive a SIGCHLD signal. Then, the parent process will re-fork-execvp the child process again.

I find the system memory(NOT includes the buffers and caches) will go higher and higher and even I shutdown all of the parent process and the child processes, it will not go down. Why?

My environment is Linux 2.6.9 and g++ 3.4.2

The following is my code:

//////////////////////////////////////////////////////////////////////////////////
// fork.cpp
// g++ -Wall fork.cpp -o fork

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

char* argv[] = { "data", (char*)0 };

void run()
{
// Child process
if (fork() == 0)
if (execvp("date", argv) < 0)
exit(0);
}

// SIGCHLD signal handler
void sig_child(int sig)
{
pid_t pid;
int stat;
while ((pid = waitpid(-1, &stat, WNOHANG)) > 0)
run();
}

int main()
{
// Setup signal handler
struct sigaction act;
memset(&act, 0, sizeof(act));
act.sa_handler = sig_child;
sigemptyset(&act.sa_mask);
if (sigaction(SIGCHLD, &act, 0) < 0)
return -1;

// Run 100 child processes
for (int n = 0; n < 100; n++)
run();

// Zzz...
for (;
pause();
return 0;
}

//////////////////////////////////////////////////////////////////////////////////

Thanks,
Richard

What is run() doing in sig_child()? That's an infinite loop, whenever one child exits you create another.

Thanks,

Yes, That's what I want.

My question is after fork thousands and thousands processes. The memory usage will go higher and higher. Even I kill the parent process and all of child process(actually, they will exit very quickly.) The memory does not go down. It looks like memory leak.

If this is Linux, try 'cat /proc/meminfo' to see if it shows where the memory went.

It might even be in signal queues or something. Lots of processes means lots of signals.

After check /proc/meminfo, I found the memory gone is LowFree. I think this means kernel memory leak, right?

Is MemFree shrinking? What about LowTotal? MemFree should equal HighFree + LowFree. It could be that the kernel just gave you some of its unused memory and has no reason to reclaim it.

It could be. I know that "low" memory is important to the kernel and is a somewhat limited resource, but that's all I know about it. Hard for me to say whether it's leaking or just caching something somewhere without being intimately familiar with how the kernel manages memory... Also, I learned about the 'slabtop' command a few weeks ago, which shows some little-known things like inode caches that aren't counted by top; these caches can sometimes cause the typical newbie "OMG linux sez 0 bytes free!!" panic in people that otherwise know better

What kernel version are you using? If it's a genuine leak, upgrading might help. Also, this might get better viewage in the Linux subforum here, since your program as far as I can tell doesn't have any direct leaks.

One way to test I suppose... If low memory isn't really leaking, nothing should happen when you let it "run out", but if it really does run out of low memory, the kernel will not be happy. I'm not sure whether it'd panic or kill processes or what, but something ought to happen. Run from a real console(ctrl-alt-F1 though F6 brings you to consoles 1-6, ctrl-alt-F7 brings you back to the window manager) to let you see kernel messages.