1 | /* threadtest.c |
2 | * by: john stultz (johnstul@us.ibm.com) |
3 | * (C) Copyright IBM 2004, 2005, 2006, 2012 |
4 | * Licensed under the GPLv2 |
5 | * |
6 | * To build: |
7 | * $ gcc threadtest.c -o threadtest -lrt |
8 | * |
9 | * This program is free software: you can redistribute it and/or modify |
10 | * it under the terms of the GNU General Public License as published by |
11 | * the Free Software Foundation, either version 2 of the License, or |
12 | * (at your option) any later version. |
13 | * |
14 | * This program is distributed in the hope that it will be useful, |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
17 | * GNU General Public License for more details. |
18 | */ |
19 | #include <stdio.h> |
20 | #include <unistd.h> |
21 | #include <stdlib.h> |
22 | #include <sys/time.h> |
23 | #include <pthread.h> |
24 | #include "../kselftest.h" |
25 | |
26 | /* serializes shared list access */ |
27 | pthread_mutex_t list_lock = PTHREAD_MUTEX_INITIALIZER; |
28 | /* serializes console output */ |
29 | pthread_mutex_t print_lock = PTHREAD_MUTEX_INITIALIZER; |
30 | |
31 | |
32 | #define MAX_THREADS 128 |
33 | #define LISTSIZE 128 |
34 | |
35 | int done = 0; |
36 | |
37 | struct timespec global_list[LISTSIZE]; |
38 | int listcount = 0; |
39 | |
40 | |
41 | void checklist(struct timespec *list, int size) |
42 | { |
43 | int i, j; |
44 | struct timespec *a, *b; |
45 | |
46 | /* scan the list */ |
47 | for (i = 0; i < size-1; i++) { |
48 | a = &list[i]; |
49 | b = &list[i+1]; |
50 | |
51 | /* look for any time inconsistencies */ |
52 | if ((b->tv_sec <= a->tv_sec) && |
53 | (b->tv_nsec < a->tv_nsec)) { |
54 | |
55 | /* flag other threads */ |
56 | done = 1; |
57 | |
58 | /*serialize printing to avoid junky output*/ |
59 | pthread_mutex_lock(&print_lock); |
60 | |
61 | /* dump the list */ |
62 | printf("\n" ); |
63 | for (j = 0; j < size; j++) { |
64 | if (j == i) |
65 | printf("---------------\n" ); |
66 | printf("%lu:%lu\n" , list[j].tv_sec, list[j].tv_nsec); |
67 | if (j == i+1) |
68 | printf("---------------\n" ); |
69 | } |
70 | printf("[FAILED]\n" ); |
71 | |
72 | pthread_mutex_unlock(&print_lock); |
73 | } |
74 | } |
75 | } |
76 | |
77 | /* The shared thread shares a global list |
78 | * that each thread fills while holding the lock. |
79 | * This stresses clock synchronization across cpus. |
80 | */ |
81 | void *shared_thread(void *arg) |
82 | { |
83 | while (!done) { |
84 | /* protect the list */ |
85 | pthread_mutex_lock(&list_lock); |
86 | |
87 | /* see if we're ready to check the list */ |
88 | if (listcount >= LISTSIZE) { |
89 | checklist(list: global_list, LISTSIZE); |
90 | listcount = 0; |
91 | } |
92 | clock_gettime(CLOCK_MONOTONIC, &global_list[listcount++]); |
93 | |
94 | pthread_mutex_unlock(&list_lock); |
95 | } |
96 | return NULL; |
97 | } |
98 | |
99 | |
100 | /* Each independent thread fills in its own |
101 | * list. This stresses clock_gettime() lock contention. |
102 | */ |
103 | void *independent_thread(void *arg) |
104 | { |
105 | struct timespec my_list[LISTSIZE]; |
106 | int count; |
107 | |
108 | while (!done) { |
109 | /* fill the list */ |
110 | for (count = 0; count < LISTSIZE; count++) |
111 | clock_gettime(CLOCK_MONOTONIC, &my_list[count]); |
112 | checklist(list: my_list, LISTSIZE); |
113 | } |
114 | return NULL; |
115 | } |
116 | |
117 | #define DEFAULT_THREAD_COUNT 8 |
118 | #define DEFAULT_RUNTIME 30 |
119 | |
120 | int main(int argc, char **argv) |
121 | { |
122 | int thread_count, i; |
123 | time_t start, now, runtime; |
124 | char buf[255]; |
125 | pthread_t pth[MAX_THREADS]; |
126 | int opt; |
127 | void *tret; |
128 | int ret = 0; |
129 | void *(*thread)(void *) = shared_thread; |
130 | |
131 | thread_count = DEFAULT_THREAD_COUNT; |
132 | runtime = DEFAULT_RUNTIME; |
133 | |
134 | /* Process arguments */ |
135 | while ((opt = getopt(argc, argv, "t:n:i" )) != -1) { |
136 | switch (opt) { |
137 | case 't': |
138 | runtime = atoi(optarg); |
139 | break; |
140 | case 'n': |
141 | thread_count = atoi(optarg); |
142 | break; |
143 | case 'i': |
144 | thread = independent_thread; |
145 | printf("using independent threads\n" ); |
146 | break; |
147 | default: |
148 | printf("Usage: %s [-t <secs>] [-n <numthreads>] [-i]\n" , argv[0]); |
149 | printf(" -t: time to run\n" ); |
150 | printf(" -n: number of threads\n" ); |
151 | printf(" -i: use independent threads\n" ); |
152 | return -1; |
153 | } |
154 | } |
155 | |
156 | if (thread_count > MAX_THREADS) |
157 | thread_count = MAX_THREADS; |
158 | |
159 | |
160 | setbuf(stdout, NULL); |
161 | |
162 | start = time(0); |
163 | strftime(buf, 255, "%a, %d %b %Y %T %z" , localtime(&start)); |
164 | printf("%s\n" , buf); |
165 | printf("Testing consistency with %i threads for %ld seconds: " , thread_count, runtime); |
166 | fflush(stdout); |
167 | |
168 | /* spawn */ |
169 | for (i = 0; i < thread_count; i++) |
170 | pthread_create(&pth[i], 0, thread, 0); |
171 | |
172 | while (time(&now) < start + runtime) { |
173 | sleep(1); |
174 | if (done) { |
175 | ret = 1; |
176 | strftime(buf, 255, "%a, %d %b %Y %T %z" , localtime(&now)); |
177 | printf("%s\n" , buf); |
178 | goto out; |
179 | } |
180 | } |
181 | printf("[OK]\n" ); |
182 | done = 1; |
183 | |
184 | out: |
185 | /* wait */ |
186 | for (i = 0; i < thread_count; i++) |
187 | pthread_join(pth[i], &tret); |
188 | |
189 | /* die */ |
190 | if (ret) |
191 | ksft_exit_fail(); |
192 | return ksft_exit_pass(); |
193 | } |
194 | |