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 syncronization 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(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(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