1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97 | #include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
typedef struct
{
size_t thread_count;
size_t next_thread; // next thread to print
} shared_data_t;
typedef struct
{
size_t thread_num;
shared_data_t* shared_data;
} private_data_t;
int create_threads(shared_data_t* shared_data);
void* run(void* data);
int main(int argc, char* argv[])
{
shared_data_t* shared_data = (shared_data_t*) calloc(1, sizeof(shared_data_t));
if ( shared_data == NULL )
return (void)fprintf(stderr, "error: could not allocate shared memory\n"), 1;
shared_data->thread_count = sysconf(_SC_NPROCESSORS_ONLN);
if ( argc >= 2 )
shared_data->thread_count = strtoull(argv[1], NULL, 10);
shared_data->next_thread = 0;
struct timespec start_time;
clock_gettime(CLOCK_MONOTONIC, &start_time);
int error = create_threads(shared_data);
if ( error )
return error;
struct timespec finish_time;
clock_gettime(CLOCK_MONOTONIC, &finish_time);
double elapsed_seconds = finish_time.tv_sec - start_time.tv_sec
+ 1e-9 * (finish_time.tv_nsec - start_time.tv_nsec);
printf("Hello execution time %.9lfs\n", elapsed_seconds);
free(shared_data);
return 0;
}
int create_threads(shared_data_t* shared_data)
{
pthread_t* threads = (pthread_t*) malloc(shared_data->thread_count * sizeof(pthread_t));
if ( threads == NULL )
return (void)fprintf(stderr, "error: could not allocate memory for %zu threads\n", shared_data->thread_count), 2;
private_data_t* private_data = (private_data_t*) calloc(shared_data->thread_count, sizeof(private_data_t));
if ( private_data == NULL )
return (void)fprintf(stderr, "error: could not allocate private memory for %zu threads\n", shared_data->thread_count), 3;
for ( size_t index = 0; index < shared_data->thread_count; ++index )
{
private_data[index].thread_num = index;
private_data[index].shared_data = shared_data;
pthread_create(&threads[index], NULL, run, &private_data[index]);
}
printf("Hello world from main thread\n");
for ( size_t index = 0; index < shared_data->thread_count; ++index )
pthread_join(threads[index], NULL);
free(private_data);
free(threads);
return 0;
}
void* run(void* data)
{
private_data_t* private_data = (private_data_t*)data;
shared_data_t* shared_data = private_data->shared_data;
size_t thread_num = (*private_data).thread_num;
size_t thread_count = shared_data->thread_count;
while ( shared_data->next_thread < thread_num )
; // busy wait
printf("Hello world from secondary thread %zu of %zu\n", thread_num, thread_count);
++shared_data->next_thread;
return NULL;
}
|