Arbeit zwischen Fäden aufteilen? (pthread)

Question

Ich habe ein Programm erstellt, um einige Zahlen für ein Schulprojekt zu berechnen. Angenommen, ich habe 10 Threads, aber 42 Elemente, die verarbeitet werden sollen. Ich möchte, dass sie alle Elemente gleichmäßig verarbeiten und eine gleich große Anzahl von Jobs übernehmen. Ich benutze die POSIX Pthread-Bibliothek, ich weiß, dass es etwas mit Mutex zu tun hat, aber ich bin mir nicht ganz sicher.

Hier ist ein vereinfachtes Beispiel für das, was ich mache, aber ich möchte die Arbeitsbelastung gleichmäßig ausgleichen.

#include <stdio.h> 
#include <stdlib.h> 
#include <pthread.h> 

int numbers = { 1, 78, 19, 49, 14, 1, 14. 19, 57, 15, 95, 19, 591, 591 }; 

void* method() { 
    for(size_t i = 0; i < 14; i++) { 
    printf("%d\n", (numbers[i] * 2)); 
    } 
} 

int main(int argc, char const *argv[]) { 
    pthread_t th[10]; 
    for (size_t i = 0; i < 10; i++) { 
    pthread_create(&th[i], NULL, method, NULL); 
    } 
    return 0; 
} 

Answer 1

Sie möchten, dass jeder Thread bestimmte Indizes in der Tabelle verarbeitet. Sie müssen die Tabelle nicht mit Mutex schützen, solange Sie die Arbeit ordnungsgemäß zwischen Threads teilen, damit sie nicht nach den gleichen Daten suchen.

Eine Idee:

/* this structure will wrap all thread's data */ 
struct work 
{ 
    size_t start, end; 
    pthread_t  tid; 
}; 

void* method(void*); 
#define IDX_N 42 /* in this example */ 
int main(int argc, char const *argv[]) 
{ 
    struct work w[10]; 
    size_t idx_start, idx_end, idx_n = IDX_N/10; 
    idx_start = 0; 
    idx_end = idx_start + idx_n; 
    for (size_t i = 0; i < 10; i++) 
    { 
    w[i].start = idx_start; /* starting index */ 
    w[i].end = idx_end; /* ending index */ 
    /* pass the information about starting and ending point for each 
    * thread by pointing it's argument to appropriate work struct */ 
    pthread_create(&w[i], NULL, method, (void*)&work[i]); 
    idx_start = idx_end; 
    idx_end = (idx_end + idx_n < IDX_N ? idx_end + idx_n : IDX_N); 
    } 
    return 0; 
} 
void* 
method(void* arg) 
{ 
    struct work *w = (struct work* arg); 
    /* now each thread can learn where it should start and stop 
    * by examining indices that were passed to it in argument */ 
    for(size_t i = w->start; i < w->end; i++) 
    printf("%d\n", (numbers[i] * 2)); 
    return NULL; 
} 

Für etwas komplexeres Beispiel Sie this und this überprüfen können.

Answer 2

Wenn Sie im Voraus wissen, (das heißt, bevor die Fäden beginnen), wie viele Elemente, die Sie verarbeiten müssen, Sie müssen sie nur unter den Fäden partitionieren. Sagen Sie zum Beispiel, dass der erste Thread die Elemente 0 bis 9, der nächste bis 10 bis 19 oder was auch immer verarbeitet.