Pasarle trabajo a un hilo en C

Un struct de argumentos por hilo, para que nada se comparta por accidente.

#include <pthread.h>

typedef struct {
    const int *values;
    size_t start;
    size_t end;
    long sum;
} Task;

static void *sum_range(void *arg) {
    Task *task = arg;
    task->sum = 0;
    for (size_t i = task->start; i < task->end; i++) {
        task->sum += task->values[i];
    }
    return NULL;
}

long parallel_sum(const int *values, size_t n, Task *tasks, size_t workers) {
    pthread_t threads[8];
    size_t chunk = (n + workers - 1) / workers;

    for (size_t w = 0; w < workers; w++) {
        size_t start = w * chunk;
        tasks[w].values = values;
        tasks[w].start = start;
        tasks[w].end = (start + chunk < n) ? start + chunk : n;
        pthread_create(&threads[w], NULL, sum_range, &tasks[w]);
    }

    long total = 0;
    for (size_t w = 0; w < workers; w++) {
        pthread_join(threads[w], NULL);
        total += tasks[w].sum;
    }
    return total;
}

Cómo funciona

1. Un puntero a un arreglo de structs le da a cada hilo el suyo.
2. El struct lleva la entrada y el lugar para el resultado.
3. La memoria debe sobrevivir al hilo: nada de locales de un marco muerto.

Palabras clave y builtins usados aquí

• NULL
• const
• for
• int
• long
• return
• size_t
• static
• struct
• typedef
• void

El intento, en números

Líneas

37

Caracteres a escribir

774

Tokens

253

Ritmo de tres estrellas

100 tpm

Al ritmo de tres estrellas de 100 tokens por minuto, este intento toma unos 152 segundos.

Escribe este fragmento

Paso 2 de 3 en Arrancar hilos; paso 2 de 10 en Hilos y concurrencia.

← Anterior Siguiente →