[mirror_ubuntu-bionic-kernel.git] / tools / testing / selftests / timers / threadtest.c

/* threadtest.c
 *		by: john stultz (johnstul@us.ibm.com)
 *		(C) Copyright IBM 2004, 2005, 2006, 2012
 *		Licensed under the GPLv2
 *
 *  To build:
 *	$ gcc threadtest.c -o threadtest -lrt
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/time.h>
#include <pthread.h>
#include "../kselftest.h"

/* serializes shared list access */
pthread_mutex_t list_lock = PTHREAD_MUTEX_INITIALIZER;
/* serializes console output */
pthread_mutex_t print_lock = PTHREAD_MUTEX_INITIALIZER;


#define MAX_THREADS 128
#define LISTSIZE 128

int done = 0;

struct timespec global_list[LISTSIZE];
int listcount = 0;


void checklist(struct timespec *list, int size)
{
	int i, j;
	struct timespec *a, *b;

	/* scan the list */
	for (i = 0; i < size-1; i++) {
		a = &list[i];
		b = &list[i+1];

		/* look for any time inconsistencies */
		if ((b->tv_sec <= a->tv_sec) &&
			(b->tv_nsec < a->tv_nsec)) {

			/* flag other threads */
			done = 1;

			/*serialize printing to avoid junky output*/
			pthread_mutex_lock(&print_lock);

			/* dump the list */
			printf("\n");
			for (j = 0; j < size; j++) {
				if (j == i)
					printf("---------------\n");
				printf("%lu:%lu\n", list[j].tv_sec, list[j].tv_nsec);
				if (j == i+1)
					printf("---------------\n");
			}
			printf("[FAILED]\n");

			pthread_mutex_unlock(&print_lock);
		}
	}
}

/* The shared thread shares a global list
 * that each thread fills while holding the lock.
 * This stresses clock syncronization across cpus.
 */
void *shared_thread(void *arg)
{
	while (!done) {
		/* protect the list */
		pthread_mutex_lock(&list_lock);

		/* see if we're ready to check the list */
		if (listcount >= LISTSIZE) {
			checklist(global_list, LISTSIZE);
			listcount = 0;
		}
		clock_gettime(CLOCK_MONOTONIC, &global_list[listcount++]);

		pthread_mutex_unlock(&list_lock);
	}
	return NULL;
}


/* Each independent thread fills in its own
 * list. This stresses clock_gettime() lock contention.
 */
void *independent_thread(void *arg)
{
	struct timespec my_list[LISTSIZE];
	int count;

	while (!done) {
		/* fill the list */
		for (count = 0; count < LISTSIZE; count++)
			clock_gettime(CLOCK_MONOTONIC, &my_list[count]);
		checklist(my_list, LISTSIZE);
	}
	return NULL;
}

#define DEFAULT_THREAD_COUNT 8
#define DEFAULT_RUNTIME 30

int main(int argc, char **argv)
{
	int thread_count, i;
	time_t start, now, runtime;
	char buf[255];
	pthread_t pth[MAX_THREADS];
	int opt;
	void *tret;
	int ret = 0;
	void *(*thread)(void *) = shared_thread;

	thread_count = DEFAULT_THREAD_COUNT;
	runtime = DEFAULT_RUNTIME;

	/* Process arguments */
	while ((opt = getopt(argc, argv, "t:n:i")) != -1) {
		switch (opt) {
		case 't':
			runtime = atoi(optarg);
			break;
		case 'n':
			thread_count = atoi(optarg);
			break;
		case 'i':
			thread = independent_thread;
			printf("using independent threads\n");
			break;
		default:
			printf("Usage: %s [-t <secs>] [-n <numthreads>] [-i]\n", argv[0]);
			printf("	-t: time to run\n");
			printf("	-n: number of threads\n");
			printf("	-i: use independent threads\n");
			return -1;
		}
	}

	if (thread_count > MAX_THREADS)
		thread_count = MAX_THREADS;


	setbuf(stdout, NULL);

	start = time(0);
	strftime(buf, 255, "%a, %d %b %Y %T %z", localtime(&start));
	printf("%s\n", buf);
	printf("Testing consistency with %i threads for %ld seconds: ", thread_count, runtime);
	fflush(stdout);

	/* spawn */
	for (i = 0; i < thread_count; i++)
		pthread_create(&pth[i], 0, thread, 0);

	while (time(&now) < start + runtime) {
		sleep(1);
		if (done) {
			ret = 1;
			strftime(buf, 255, "%a, %d %b %Y %T %z", localtime(&now));
			printf("%s\n", buf);
			goto out;
		}
	}
	printf("[OK]\n");
	done = 1;

out:
	/* wait */
	for (i = 0; i < thread_count; i++)
		pthread_join(pth[i], &tret);

	/* die */
	if (ret)
		ksft_exit_fail();
	return ksft_exit_pass();
}
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>
e39b60f3	24	#include "../kselftest.h"
e39b60f3 JS	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
1c0a7498 JS	117	#define DEFAULT_THREAD_COUNT 8
1c0a7498 JS	118	#define DEFAULT_RUNTIME 30
e39b60f3 JS	119
	120	int main(int argc, char **argv)
	121	{
1c0a7498 JS	122	int thread_count, i;
1c0a7498 JS	123	time_t start, now, runtime;
e39b60f3 JS	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
1c0a7498 JS	131	thread_count = DEFAULT_THREAD_COUNT;
1c0a7498 JS	132	runtime = DEFAULT_RUNTIME;
e39b60f3 JS	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);
19de0f85	166	fflush(stdout);
e39b60f3 JS	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	}