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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
/*
* Beat up the pthread_key_create and pthread_key_delete
* functions.
*/
#if 0
#define CHATTY
#endif
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
const int beatup_iterations = 10000;
const int num_threads = 30;
const int max_keys = 500;
struct key_list {
struct key_list *next;
pthread_key_t key;
};
struct key_list *key_list;
pthread_mutex_t key_lock = PTHREAD_MUTEX_INITIALIZER;
/*
* Create a new key and put it at the tail of a linked list.
* If the linked list grows to a certain length, delete a key from the
* head of * the list.
*/
static void
beat_up(void)
{
struct key_list *new = malloc(sizeof *new);
struct key_list **iter, *old_key = 0;
int key_count = 0;
if (new == 0) {
fprintf(stderr, "malloc failed\n");
abort();
}
new->next = 0;
if (pthread_key_create(&new->key, 0) != 0) {
fprintf(stderr, "pthread_key_create failed\n");
abort();
}
if (pthread_getspecific(new->key) != 0) {
fprintf(stderr, "new pthread_key_t resolves to non-null value\n");
abort();
}
pthread_setspecific(new->key, (void *) 1);
#ifdef CHATTY
printf("created key\n");
#endif
pthread_mutex_lock(&key_lock);
for (iter = &key_list; *iter != 0; iter = &(*iter)->next)
key_count++;
*iter = new;
if (key_count > max_keys) {
old_key = key_list;
key_list = key_list->next;
}
pthread_mutex_unlock(&key_lock);
if (old_key != 0) {
#ifdef CHATTY
printf("deleting key\n");
#endif
pthread_key_delete(old_key->key);
}
}
static void *
thread(void *arg)
{
int i;
for (i = 0; i < beatup_iterations; i++)
beat_up();
return 0;
}
int
main(void)
{
int i;
pthread_attr_t detached_thread;
pthread_attr_init(&detached_thread);
pthread_attr_setdetachstate(&detached_thread, PTHREAD_CREATE_DETACHED);
for (i = 0; i < num_threads; i++) {
pthread_t thread_id;
while (pthread_create(&thread_id, &detached_thread, thread, 0) == EAGAIN) {
/* let some threads die, so system can breathe. :) */
sleep(1);
}
}
pthread_exit(0);
}
|
