X
Hallo,
jetzt glaub ich hab ichs verstanden: Der Mutex ist nur dazu da den Zugriff auf die Condition-Variable abzusichern, das ist alles. Das Warten hab ich jetzt mit barrier realisiert (aber ohne den hauptthread mitrechnen zu lassen):
void *thread_function(void *arg)
{
while(arg->run)
{
process_data(arg->data, arg->start, arg->len);
pthread_barrier_wait(arg->barrier);
pthread_mutex_lock(arg->mutex);
pthread_cond_wait(arg->cond, arg->mutex);
pthread_mutex_unlock(arg->mutex);
}
pthread_exit(NULL);
}
void do_something(threaddata_t *threads)
{
if(!threads->created) {
pthread_barrier_init(&threads->barrier,NULL,threads->N+1);
pthread_cond_init(&threads->cond,NULL);
pthread_mutex_init(&threads->mutex,NULL);
for(int i=0;i<threads->N;i++) {
threads->threads_arg[i].cond = &threads->cond;
threads->threads_arg[i].mutex = &threads->mutex;
threads->threads_arg[i].barrier = &threads->barrier;
threads->threads_arg[i].data = threads->data;
threads->threads_arg[i].start = (threads->data_len/threads->N)*i;
threads->threads_arg[i].len = (threads->data_len/threads->N);
threads->threads_arg[i].run = 1;
pthread_create(&threads->thread[i], &threads->attr, thread_function, &threads->threads_arg[i]);
}
threads->created=1;
}
else {
pthread_cond_broadcast(&threads->cond);
}
/* soll hier warten bis alle Threads wieder pthread_cond_wait erreicht haben */
pthread_barrier_wait(&threads->barrier);
}
Es funktioniert bis jetzt problemlos und die Geschwindigkeit hat sich bei 4 threads auf einem dual-core mit Hyperthreading mehr als verdoppelt, ich denke damit scheint die Umsetzung auch ganz gut zu sein.
Die Berechnung führen alle Threads auf genau dem gleichen Objekt zu, schreiben tun sie aber in unterschiedliche Bereiche (beim Lesen gibt es z.T überschneidungen, aber das ist ja kein Problem). Grundsätzlich ist der Lese- und Schreibbereich getrennt, das heißt in einem Teil wird nur gelesen, in einem anderen nur geschrieben.
Vielen Dank!
