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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#include <stdatomic.h>
#include <string.h>
#include <unistd.h>
#include <dispatch/dispatch.h>
#include <pthread.h>
atomic_int finished_enqueueing_work = 0;
atomic_int thread_count = 0;
void
doing_the_work_1(void *in)
{
// This is only counted once because the first job in the queue
// starves all the others.
atomic_fetch_add(&thread_count, 1);
while (1)
sleep (1);
}
void
submit_work_1a(void *in)
{
dispatch_queue_t *work_performer_1 = (dispatch_queue_t*) in;
dispatch_async_f (*work_performer_1, NULL, doing_the_work_1);
dispatch_async_f (*work_performer_1, NULL, doing_the_work_1);
}
void
submit_work_1b(void *in)
{
dispatch_queue_t *work_performer_1 = (dispatch_queue_t*) in;
dispatch_async_f (*work_performer_1, NULL, doing_the_work_1);
dispatch_async_f (*work_performer_1, NULL, doing_the_work_1);
atomic_fetch_add(&thread_count, 1);
while (1)
sleep (1);
}
void
doing_the_work_2(void *in)
{
atomic_fetch_add(&thread_count, 1);
while (1)
sleep (1);
}
void
submit_work_2(void *in)
{
dispatch_queue_t *work_performer_2 = (dispatch_queue_t*) in;
int i = 0;
while (i++ < 5000)
{
dispatch_async_f (*work_performer_2, NULL, doing_the_work_2);
dispatch_async_f (*work_performer_2, NULL, doing_the_work_2);
}
atomic_fetch_add(&finished_enqueueing_work, 1);
}
void
doing_the_work_3(void *in)
{
// This counts four times, since the queue is marked as CONCURRENT.
atomic_fetch_add(&thread_count, 1);
while (1)
sleep (1);
}
void
submit_work_3(void *in)
{
dispatch_queue_t *work_performer_3 = (dispatch_queue_t*) in;
dispatch_async_f (*work_performer_3, NULL, doing_the_work_3);
dispatch_async_f (*work_performer_3, NULL, doing_the_work_3);
dispatch_async_f (*work_performer_3, NULL, doing_the_work_3);
dispatch_async_f (*work_performer_3, NULL, doing_the_work_3);
}
void
stopper ()
{
while (1)
sleep (1);
}
int main (int argc, const char **argv)
{
dispatch_queue_t work_submittor_1 = dispatch_queue_create ("com.apple.work_submittor_1", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t work_submittor_2 = dispatch_queue_create ("com.apple.work_submittor_and_quit_2", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t work_submittor_3 = dispatch_queue_create ("com.apple.work_submittor_3", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t work_performer_1 = dispatch_queue_create ("com.apple.work_performer_1", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t work_performer_2 = dispatch_queue_create ("com.apple.work_performer_2", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t work_performer_3 = dispatch_queue_create ("com.apple.work_performer_3", DISPATCH_QUEUE_CONCURRENT);
dispatch_async_f (work_submittor_1, (void*) &work_performer_1, submit_work_1a);
dispatch_async_f (work_submittor_1, (void*) &work_performer_1, submit_work_1b);
dispatch_async_f (work_submittor_2, (void*) &work_performer_2, submit_work_2);
dispatch_async_f (work_submittor_3, (void*) &work_performer_3, submit_work_3);
// Spin up threads with each of the different libdispatch QoS values.
dispatch_async (dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
pthread_setname_np ("user initiated QoS");
atomic_fetch_add(&thread_count, 1);
while (1)
sleep (10);
});
dispatch_async (dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
pthread_setname_np ("user interactive QoS");
atomic_fetch_add(&thread_count, 1);
while (1)
sleep (10);
});
dispatch_async (dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0), ^{
pthread_setname_np ("default QoS");
atomic_fetch_add(&thread_count, 1);
while (1)
sleep (10);
});
dispatch_async (dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
pthread_setname_np ("utility QoS");
atomic_fetch_add(&thread_count, 1);
while (1)
sleep (10);
});
dispatch_async (dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0), ^{
pthread_setname_np ("background QoS");
atomic_fetch_add(&thread_count, 1);
while (1)
sleep (10);
});
// Unfortunately there is no pthread_barrier on darwin.
while ((atomic_load(&thread_count) < 12) || (finished_enqueueing_work == 0))
sleep (1);
stopper ();
}
|
