C/C++ - Consiglio parallelizzazione codice con pthread

salve a tutti,
mi sto accingendo a parallelizare delle parti del mio codice.
Volevo però un consiglio su come farlo in quanto le alcune prove che ho fatto non mi hanno soddisfatto molto.
Spiego velocemente il contesto.
Ho un file output_ls contente nomi di immagini, leggo linea per linea e richiamo la funzione sift che mi crea un file di testo contenente i sift.
Il mio non è tanto un problema di come fare con i thread più che altro qual'è la soluzione migliore, io avevo pensato di leggere una linea e passarla al thread che si occupi del sift e nel mentre passare un altra linea.
Mi è venuta fuori una cosa del genere che però mi pare vada sempre in seriale : (

void *sift_thread (void* st) {
	
	char* str;
	string name;
	size_t split;
	string pgm="../Sift_Immagini/";
	string pgm_C=pgm;
	str = (char*) st;
	string line(str);
	if ( line != "") {
	split = line.find_last_of(".");	            //parte necessaria 
	name = line.substr(0, split);                 // per comporre il nome
	pgm_C += name;                                // da passare alla
	pgm_C += ".pgm";                              //  sift correttamente
	sift_extract("../siftpp/glx/sift",pgm_C.c_str());
	pgm_C = pgm;

	}
	pthread_exit(0);
}	


void sift (void) {
	string line;
	char st[20];
	pthread_t threads[NUM_THREADS];
    int rc;
    int t=0;
	pthread_mutex_init(&mutexsum, NULL);
	ifstream in("../output_ls");
	while ( in.good() ) {                                   
	t++;
	getline(in,line);                             //lettura linea
	strcpy(st,line.c_str());
        rc = pthread_create(&threads[t], NULL, sift_thread, (void*)st);
      }
      
     for (int i=0; i<t; i++) { 
      pthread_join(threads[i], NULL); 
   }
 }

è un codice un pò improvvisato con nomi di variabile ancora molto "fantasiosi" per brutta abitudine faccio pulizia del codice quasi sempre verso la fine
spero comunque di essermi spiegato.

grazie!
Saluti
Riccardo


p.s: non capisco come mai mi da presumibilmente codice Delphi

Dai un'occhiata qui computing.llnl.gov/tutorials/pthreads/.

La lettura da file è molto più lenta, quindi, mi sembra del tutto plausibile che l'esecuzione possa sembrare seriale. Fai fare qualcosa di più lento al tuo thread e poi facci sapere.

Una soluzione migliore non c'è... io rimuoverei il thread, ovviamente la scelta dipende anche da quello che deve fare il programma intero.

già letto, tre quarti delle cose che so su i thread vengono proprio da qui

i thread fanno già qualcosa di più lento infatti la sift extract scrive su di un file all'incirca un migliaio di righe.
Processando 5 immagini da seriale a parallelo guadagno 3 secondi quando mi aspettavo un pò di più, ho provato allora ad aumentare il numero delle immagini per vedere i risultati ma sono occorso in un errore,
infatti con 13 immagini quando lo mando in esecuzione mi da

*** stack smashing detected ***: ./a.out terminated

creo troppi thread? mi piaceva l'idea di avere un thread che si occupa di una sola immagine ! mi aspettavo così che tutti iniziassero la scrittura del file e si passassero il controllo man a mano.
come potrei fare?

comunque il programma finito è un progetto per l'università ed essendo un programma molto pesante (al momento impiego 330secondi per 11 immagini) i thread mi sembravano una cosa da inseririci per fare in modo di migliorare un pò le prestazioni !

Si. esiste un massimo numero di thread per processo.... puoi creare più processi che a loro volta si occupano di lanciare diversi thread.

La velocità dipende da tanti fattori... Se il tuo programma utilizza tanto l'hd allora il principale motivo di lentezza è quello, poi ovviamente, non avendo visto il codice, non posso dirti di più.

ho cambiato un pò tutto, creo un gruppo di thread (ora ne ho fissati 6) a cui passo l'indice della riga da leggersi così che si occupano ognuno del suo file, raggiungono poi una bariera e ricominciano da capo con un nuovo "set" di righe da processare fino alla fine del file. Dato che il numero di righe non sarà quasi mai un multiplo perfetto di 6 ho un controllo sulla creazione dei thread basato sul numero effettivo di righe ( es: se ho 10 righe la prima volta creo 6 thread che si occupano delle loro righe, poi ne creo solo 4 per le restanti ).

Non mi piace però che ogni thread si debba aprire la sua connessione al file per leggere la riga designatagli se questa connessione fosse condivisa credo che guadagnerei qualcosa in prestazioni.

sempre con i pthread sono arrivato ad un altro problema:

in un altro metodo devo riempire due matrici con valori presi da un file di testo (12000 * 128 campi circa) essendo che devo farlo sempre per 2 matrici ogni volta che viene invocato ho pensato di far fare questo lavoro a 2 thread distinti in parallelo (ognuno riempie la sua matrice)
il riempimento lo faccio così

void *fillMatrixWithSift(void *app){
	
	struct matrix *fill; 
	fill = (struct matrix *) app;

	const char *file = fill->stringa;
	int n = fill->dimensione;	
	int **val = fill->M;
    fstream filestr;
    float trash;
    filestr.open (file, fstream::in);
 
 //#pragma omp parallel for num_threads (THREADS)
    for(int i=0;i<n;i++){
        for(int j=0;j<4;j++){
        filestr >> trash;
        }
        for(int j=0; j<128;j++){
        filestr >> val[i][j];
        }
    }
    filestr.close();	
    pthread_exit((void*) val);
} 

la matrice però non si riempiva correttamente e sono giunto alla conclusione che è per colpa del openMP infatti commetandolo la matrice si riempie correttamente.
Il problema è che inserendo i thread e commentando l'openMP ottengo le stesse prestazioni che creando le matrici serialmente e riempiendole con l'openMP
quindi vorrei poter usare i due thread che a sua volta si suddividono il ciclo for con l'openMP però non capisco a cosa si debba il riempimento della matrice errato ( alcune righe sono corrette altre tutte a 0 )

spero di essermi circa spiegato

Non conosco bene OpenMP, ma il problema dovrebbe essere sempre lo stesso: thread poco robusti che ti fanno casino (ad esempio, due o più thread potrebbero riempire, erroneamente, le stessa linee, lasciandone alcune "non inizializzate" (ossia a zero se la matrice è globale).
Però, come ti dicevo, non conosco bene OpenMP, quindi potrei sbagliarmi.