[C][Linux] Problema gestione della memoria allocata

[domenan]

Ciao a tutti, vi descrivo il problema:
In anzi tutto vi informo che programmo su linux, per compilare uso gcc, e il programma usa le librerie gtk.

Dunque il problema è che ho la necessità di usare il codice, scritto qui sotto. Il codice si trova all'interno di un file header.h e la funzione al suo interno viene avviata da un programma main.c ogni qualvolta ce ne sia la necessità in multitasking (con l'uso dei thread), vi informo anche che la funzione deve essere avviata anche decine di volte senza che termini il programma main.c.

Il problema, come da titolo, è che la funzione ogni qualvolta viene avviata alloca 8MB di memoria , diventando insostenibile al 10° riavvio (80MB !!!). Io non sono molto esperto su l'uso del comando free() o g_free() e in generale su l'allocazione di memoria, per tanto vi chiedo un consiglio su come de-allocare la memoria, onde evitare l'allocazione di tutta la mia ram.

Vi posto il codice del file header.h:

/* Programma per comunicare con un servere Pop3. 
 * 24/01/2009
 *//* Variables and costants definition */
    

	int nmail;
	gchar *addr, *user, *pass;



/* Main program begin */
void *checkm()
{   
	/* Local variables definition */
	#define MAXLINE 256
    int sock_fd;
    struct sockaddr_in serv_add;
	
    char recvbuff[MAXLINE+1], sendbuff1[MAXLINE+1] = "user ", sendbuff2[MAXLINE+1] = "pass ", sendbuff3[MAXLINE+1] = "stat\r\n";
    int nread, nwrite; 
	
    strcat(sendbuff1, user);
    strcat(sendbuff1, "\r\n");
    strcat(sendbuff2, pass);
    strcat(sendbuff2, "\r\n");

	
	/* create socket */
    if ( (sock_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
	perror("Socket creation error");
    }
	
	
    /* initialize address */
    memset((void *) &serv_add, 0, sizeof(serv_add)); /* clear server address */
    serv_add.sin_family = AF_INET;                   /* address type is INET */
    serv_add.sin_port = htons(110);                    /* 110 da pop3 protocol */
    
	
	/* build address using inet_pton */
    if ( (inet_pton(AF_INET, addr, &serv_add.sin_addr)) <= 0) { /* ottengo l'indirizzo del server, che viene fornito come argomento */
	perror("Address creation error");				/* Il server deve essere in formato dotted decimal */
    }
    
	
	/* extablish connection */
    if (connect(sock_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
	perror("Connection error");
    }
    
	
	/* avvia funzione di comunicazione con il server */
 

	/* Ricevo il saluto dal server */
    nread = read(sock_fd, recvbuff, sizeof(recvbuff)); //sizeof: per leggere fino alla fine
    recvbuff[nread] = 0;
    fputs(recvbuff, stdout);
	
	
    /* Comunico al server il comando per il log-in/utente (es. "user domenan")*/
    nwrite = send(sock_fd, sendbuff1, strlen(sendbuff1), 0);  
	
	
    /* Ricevo la risposta del server */
    nread= recv(sock_fd, recvbuff, sizeof(recvbuff), 0);
    recvbuff[nread] = 0;
    fputs(recvbuff, stdout);
	
	
    /* Comunico al server il comando per il log-in/pass (es. "pass domenan")*/
	nwrite = send(sock_fd, sendbuff2, strlen(sendbuff2), 0);  
	
	
    /* Ricevo la risposta del server */
    nread= recv(sock_fd, recvbuff, sizeof(recvbuff), 0);
    recvbuff[nread] = 0;
    fputs(recvbuff, stdout);
	
	
    /* Comunico al server il comando per vedere quanti messaggi sono presenti (es. "stat")*/
    nwrite = send(sock_fd, sendbuff3, strlen(sendbuff3), 0);  
	
	
    /* Ricevo la risposta del server */
    nread= recv(sock_fd, recvbuff, sizeof(recvbuff), 0);
    recvbuff[nread] = 0;
    fputs(recvbuff, stdout);
	
	
	/* Estraggo il numero che indentifica la quantità di e-mail*/   
 	sscanf (recvbuff, "+OK %d", &nmail);
    printf("%d\n", nmail);
	
	/* Visualizzo il numero delle mail sulla label1win */  	
	smail = g_strdup_printf ("%d",nmail);
	gtk_label_set_text(GTK_LABEL(label1win), smail);
	
	/* Chiuso la connessione*/  
	close(sock_fd);
	
	
	return(0);
}

Ecco il comando presente nel codice main.c che avvia la funzione precedentemente postata:

		iIDthread = pthread_create(&IDthread1, NULL, checkm, NULL);
		if (iIDthread != 0) {
        	g_printf("Creazione thread fallita");
		}

Sono nelle vostre mani.

[shodan]

Non mi sembra che la funzione allochi memoria con malloc o simili. Sicuro sia li il problema? o che non sia prima o dopo l'invocazione del thread?

[domenan]

Ho notato che ad allocare tutta quella memoria non è la funzione contenuta nel file header.h ma il thread. In fatti se chiamo la funzione senza il thread non ci sono problemi di allocazione di memoria.

Quindi chiedo: come deallocare il thread "IDthread1"?

Ho provato col il comando "free(IDthread1)" ma mi viene data una sfilza di errori enorme.

[shodan]

Non è certo quello il modo.
Il thread termina quando ha finito quello che deve fare. Al massimo puoi aspettarlo nel main con una apposita pthread_join() (consulta la documentazione a riguardo).

Piuttosto, ho visto che fai una "read()" e una "recv()" bloccanti (presumo).
Se il thread si blocca in ascolto su una di quelle e ne fai partire altri frequentemente, gli array sullo stack si accumulano mangiando memoria.

Ti consiglio di commentare l'intero blocco di funzione e vedere se decommentando un pò alla volta riesci a isolare il problema.

[domenan]

Questa sera appena torno dal lavoro controllerò se usando il comando pthread_join() avro qualche risultato migliore. Solo che con quel comando perderò quello che stavo cercado, ovvero poter eseguire altre operazioni con l'applicazione mentre viene eseguita la funzione nel file header.h.

Per quanto riguardo l'uso del comando read() viene usato per comunicare con i socket, e dubito che il problema sia in quel codice in quanto se lo avvio più volte senza l'uso del thread non ho alcun peroblema di allocazione di memoria. Comunque questa serva verificherò.

[domenan]

ho visto che fai una "read()" e una "recv()" bloccanti (presumo).

Cosa intendi per bloccati? Scusa ma sono alle prime armi.

[shodan]

Se il socket è stato creato in modalità bloccante, la read e la recv si fermano ad aspettare che arrivino dati. Se questi dati non arrivano (per vari motivi) il thread si blocca e l'unico modo per riprendere l'esecuzione è di terminarlo brutalmente.

Si può anche impostare un timeout sul socket in modo che se le due funzioni non ricevono dati entro un certo periodo di tempo il programma continua a funzionare. Sta al programmatore verificare l'avvenuta ricezione dei dati. (Comunque questo esula dal post iniziale, quindi per approfondimenti meglio se ne apri uno nuovo.)

Può darsi (è solo un'ipotesi però) che il server sia lento a rispondere (mettiamo 30s). Se in quel lasso di tempo lanci 30 thread (uno al secondo), la memoria (stack) usata dai buffer che usi aumenti di conseguenza. Calcola che anche le funzioni di libreria allocano o usano memoria che si va a sommare a quella già usata, quindi non si può sapere a priori quanta memoria viene effettivamente allocata in totale. Non vedendo allocazioni esplicite da parte tua, può essere questa la causa.

Per il join. Puoi effettuare il join un attimo prima di uscire dal main (l'id del thread però dev'essere globale se il lancio del thread stesso non avviene nel main ma in una sottofunzione.), così il programma fa quello che deve fare e il thread continua a girare in parallelo.

[domenan]

Dunque ho seguito il tuo suggerimento e ho modificato il file header.h inserendo il comando "errore = fcntl(sock,F_SETFL,O_NONBLOCK);" e il comando "pthread_join(IDthread1, NULL);" alla fine della funzione, ma nulla di nuovo.

Poi ho tolto il comando ""pthread_join(IDthread1, NULL);" e l'ho inserito all'interno del main subito dopo l'invocazione del thread. In questo caso il programma alloca 8MB (da 20,5MB allocati a 28,5MB) all'avvio della funzione e rimangono quelli per tutte le altre volte che riuso la funzione. In questo modo però perdo i vantaggi dei thread in quanto la in main per proseguire l'esecuzione deve attendere il termine della funzione.

Se invece invoco la funzione direttamente con il comando "nomefunzione();" il programma alloca solo 20,5MB senza allocare quei 8MB in più. Però non ho i vantaggi dei thread (comunque non li avrei avuti anche con il metodo precedente).

Dunque sono arrivato alla conclusione che quei famosi 8MB sono allocati dal comando di creazione del thread e non dalla funzione stessa che viene chiamata. Dimmi se sbaglio.

Qualche consiglio per ottenere il fatidico multitasking con questa funzione senza perdere un botto ti ram?
Non è proprio possibile deallocare la memoria di un thread?

Sono nelle tue mani

[shodan]

No. Se la memoria è allocata dalla pthread_create, non è accessibile.
Ma non capisco perché dovresti perdere i vantaggi del thread mettendo una pthread_join() poco prima di uscire dal main.

int main(bla bla) {
  // codice e funzioni varie.
  ...
  // lancio del thread
  ...
  // il programma continua in parallelo al thread
  ...
  pthread_join(quel che è);
  return 0;
}

Potresti provare anche una pthread_detach() ma non so cosa potrebbe succedere.

[domenan]

Dunque ho seguito il tuo suggerimento e ho modificato il file header.h inserendo il comando "errore = fcntl(sock,F_SETFL,O_NONBLOCK);" e il comando "pthread_join(IDthread1, NULL);" alla fine della funzione, ma nulla di nuovo.

inserendo il comando "pthread_join(IDthread1, NULL);" il thread funziona il multitasking ma la memoria viene allocata "male" come al solito.
Credo da aver fatto un errore nel dire che il comando "errore = fcntl(sock_fd,F_SETFL,O_NONBLOCK);" non conta, in realtà il programma da questo errore quando avvio la funzione:

Connection error: Operazione ora in corso

Dove devo mettere il comando "errore = fcntl(sock_fd,F_SETFL,O_NONBLOCK);", io l'ho messo subito dopo la creazione del socket e prima di fare la connessione.