Commit | Line | Data |
---|---|---|
e39b60f3 JS |
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 | #ifdef KTEST | |
25 | #include "../kselftest.h" | |
26 | #else | |
27 | static inline int ksft_exit_pass(void) | |
28 | { | |
29 | exit(0); | |
30 | } | |
31 | static inline int ksft_exit_fail(void) | |
32 | { | |
33 | exit(1); | |
34 | } | |
35 | #endif | |
36 | ||
37 | ||
38 | /* serializes shared list access */ | |
39 | pthread_mutex_t list_lock = PTHREAD_MUTEX_INITIALIZER; | |
40 | /* serializes console output */ | |
41 | pthread_mutex_t print_lock = PTHREAD_MUTEX_INITIALIZER; | |
42 | ||
43 | ||
44 | #define MAX_THREADS 128 | |
45 | #define LISTSIZE 128 | |
46 | ||
47 | int done = 0; | |
48 | ||
49 | struct timespec global_list[LISTSIZE]; | |
50 | int listcount = 0; | |
51 | ||
52 | ||
53 | void checklist(struct timespec *list, int size) | |
54 | { | |
55 | int i, j; | |
56 | struct timespec *a, *b; | |
57 | ||
58 | /* scan the list */ | |
59 | for (i = 0; i < size-1; i++) { | |
60 | a = &list[i]; | |
61 | b = &list[i+1]; | |
62 | ||
63 | /* look for any time inconsistencies */ | |
64 | if ((b->tv_sec <= a->tv_sec) && | |
65 | (b->tv_nsec < a->tv_nsec)) { | |
66 | ||
67 | /* flag other threads */ | |
68 | done = 1; | |
69 | ||
70 | /*serialize printing to avoid junky output*/ | |
71 | pthread_mutex_lock(&print_lock); | |
72 | ||
73 | /* dump the list */ | |
74 | printf("\n"); | |
75 | for (j = 0; j < size; j++) { | |
76 | if (j == i) | |
77 | printf("---------------\n"); | |
78 | printf("%lu:%lu\n", list[j].tv_sec, list[j].tv_nsec); | |
79 | if (j == i+1) | |
80 | printf("---------------\n"); | |
81 | } | |
82 | printf("[FAILED]\n"); | |
83 | ||
84 | pthread_mutex_unlock(&print_lock); | |
85 | } | |
86 | } | |
87 | } | |
88 | ||
89 | /* The shared thread shares a global list | |
90 | * that each thread fills while holding the lock. | |
91 | * This stresses clock syncronization across cpus. | |
92 | */ | |
93 | void *shared_thread(void *arg) | |
94 | { | |
95 | while (!done) { | |
96 | /* protect the list */ | |
97 | pthread_mutex_lock(&list_lock); | |
98 | ||
99 | /* see if we're ready to check the list */ | |
100 | if (listcount >= LISTSIZE) { | |
101 | checklist(global_list, LISTSIZE); | |
102 | listcount = 0; | |
103 | } | |
104 | clock_gettime(CLOCK_MONOTONIC, &global_list[listcount++]); | |
105 | ||
106 | pthread_mutex_unlock(&list_lock); | |
107 | } | |
108 | return NULL; | |
109 | } | |
110 | ||
111 | ||
112 | /* Each independent thread fills in its own | |
113 | * list. This stresses clock_gettime() lock contention. | |
114 | */ | |
115 | void *independent_thread(void *arg) | |
116 | { | |
117 | struct timespec my_list[LISTSIZE]; | |
118 | int count; | |
119 | ||
120 | while (!done) { | |
121 | /* fill the list */ | |
122 | for (count = 0; count < LISTSIZE; count++) | |
123 | clock_gettime(CLOCK_MONOTONIC, &my_list[count]); | |
124 | checklist(my_list, LISTSIZE); | |
125 | } | |
126 | return NULL; | |
127 | } | |
128 | ||
129 | ||
130 | int main(int argc, char **argv) | |
131 | { | |
132 | int thread_count = 1, i; | |
133 | time_t start, now, runtime = 60; | |
134 | char buf[255]; | |
135 | pthread_t pth[MAX_THREADS]; | |
136 | int opt; | |
137 | void *tret; | |
138 | int ret = 0; | |
139 | void *(*thread)(void *) = shared_thread; | |
140 | ||
141 | ||
142 | /* Process arguments */ | |
143 | while ((opt = getopt(argc, argv, "t:n:i")) != -1) { | |
144 | switch (opt) { | |
145 | case 't': | |
146 | runtime = atoi(optarg); | |
147 | break; | |
148 | case 'n': | |
149 | thread_count = atoi(optarg); | |
150 | break; | |
151 | case 'i': | |
152 | thread = independent_thread; | |
153 | printf("using independent threads\n"); | |
154 | break; | |
155 | default: | |
156 | printf("Usage: %s [-t <secs>] [-n <numthreads>] [-i]\n", argv[0]); | |
157 | printf(" -t: time to run\n"); | |
158 | printf(" -n: number of threads\n"); | |
159 | printf(" -i: use independent threads\n"); | |
160 | return -1; | |
161 | } | |
162 | } | |
163 | ||
164 | if (thread_count > MAX_THREADS) | |
165 | thread_count = MAX_THREADS; | |
166 | ||
167 | ||
168 | setbuf(stdout, NULL); | |
169 | ||
170 | start = time(0); | |
171 | strftime(buf, 255, "%a, %d %b %Y %T %z", localtime(&start)); | |
172 | printf("%s\n", buf); | |
173 | printf("Testing consistency with %i threads for %ld seconds: ", thread_count, runtime); | |
174 | ||
175 | /* spawn */ | |
176 | for (i = 0; i < thread_count; i++) | |
177 | pthread_create(&pth[i], 0, thread, 0); | |
178 | ||
179 | while (time(&now) < start + runtime) { | |
180 | sleep(1); | |
181 | if (done) { | |
182 | ret = 1; | |
183 | strftime(buf, 255, "%a, %d %b %Y %T %z", localtime(&now)); | |
184 | printf("%s\n", buf); | |
185 | goto out; | |
186 | } | |
187 | } | |
188 | printf("[OK]\n"); | |
189 | done = 1; | |
190 | ||
191 | out: | |
192 | /* wait */ | |
193 | for (i = 0; i < thread_count; i++) | |
194 | pthread_join(pth[i], &tret); | |
195 | ||
196 | /* die */ | |
197 | if (ret) | |
198 | ksft_exit_fail(); | |
199 | return ksft_exit_pass(); | |
200 | } |