🚀 go-pugleaf

Hey,

Ik zit met een raar probleem eigenlijk.  Ik heb hier een klein
testprogrammaatje gemaakt dat gebruikt maakt van de POSIX Threads.

Dit programma loopt in een oneindige lus waarin hij telkens om de vijf
seconden tien threads aanmaakt.  Geen nood, dit is opzettellijk gedaan. :-)

Als de threads worden aangemaakt, krijgen ze als argument de functie
(function) mee, waarmee de thread moet starten, en een pointer naar een
object (zijnde het argument van de functie) in dit geval een structure met
enkel een array van 4K characters.

Nu, om het gebruikte geheugen van het object vrij te geven waar de pointer
naar verwijst, _moet_ je dit doen in de functie zelf, vermits je ni weet
wanneer de functie/thread zal eindigen.  Daarmee doe ik dit ook in mijn code
met de statements "delete my_structure; my_structure = NULL".  Dit staat op
zowat elke site op het net die handelt over POSIX threads.  Als je dit
programma echter effe laat lopen onder Linux/BSD, zie je als je het proces
in het oog houdt dat het geheugen constant blijft stijgen met exact 10 x 4K
om de 5 seconden...

Onder Linux staan er altijd 2 processen van dit programma in de lijst, onder
OpenBSD maar eentje.  Doch is het geheugengedrag op beide systemen
hetzelfde, het blijft steeds meer geheugen innemen.

Nu is mijn vraag, is dit normaal?

Gezien het programma een daemon zal worden is het niet de bedoeling dat dit
na enige tijd gewoon al geheugen zal innemen :)

Is er iemand die me hierbij kan helpen?  Alvast bedankt op voorhand...

**************************************************
Linux :             $ g++ -o test test.cc -lpthread
OpenBSD :     $ g++ -o test test.cc -lthread
**************************************************

#include <string>
#include <unistd.h>
#include <stdio.h>

typedef struct my_struct
{
        char array[4096];
};

extern "C" void * function(void * _args)
{
    my_struct * my_structure = (my_struct *) _args;
    delete my_structure;
    my_structure = NULL;
    pthread_exit(NULL);
}

int main(int argc, char ** argv)
{
    bool flag = true;
    while (true)
    {
         if (flag)
        {
            pthread_t threads[10];
            for (int i = 0; i < 10; i ++)
            {
                my_struct * my_structure = new my_struct();
                strncpy(my_structure->array, "This is a string.", 17);
                pthread_create(&threads[i], NULL, function, (void *)
my_structure);
            }
            flag = false;
        }
        else
        {
            flag = true;
            sleep(5);
        }
    }
    return 1;
}