tests: kernel: posix: pthread: Add pthread test.

This test is POSIX based implementation of tests:kernel:pthread test.
It used POSIX APIs instead of Zephyr APIs.

Signed-off-by: Youvedeep Singh <[email protected]>

Author: youvedeep-singh

tests/kernel/posix/pthread/CMakeLists.txt

@@ -0,0 +1,6 @@
+include($ENV{ZEPHYR_BASE}/cmake/app/boilerplate.cmake NO_POLICY_SCOPE)
+project(NONE)
+
+target_include_directories(app PRIVATE $ENV{ZEPHYR_BASE}/include/posix)
+FILE(GLOB app_sources src/*.c)
+target_sources(app PRIVATE ${app_sources})

tests/kernel/posix/pthread/prj.conf

@@ -0,0 +1,2 @@
+CONFIG_TEST=y
+CONFIG_PTHREAD_IPC=y

tests/kernel/posix/pthread/src/pthread.c

@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) 2017 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <tc_util.h>
+#include <kernel.h>
+#include <pthread.h>
+
+#define N_THR 3
+
+#define BOUNCES 64
+
+#define STACKSZ 1024
+
+K_THREAD_STACK_ARRAY_DEFINE(stacks, N_THR, STACKSZ);
+
+void *thread_top(void *p1);
+
+PTHREAD_MUTEX_DEFINE(lock);
+
+PTHREAD_COND_DEFINE(cvar0);
+
+PTHREAD_COND_DEFINE(cvar1);
+
+PTHREAD_BARRIER_DEFINE(barrier, N_THR);
+
+K_SEM_DEFINE(main_sem, 0, 2*N_THR);
+
+static int bounce_failed;
+static int bounce_done[N_THR];
+
+static int curr_bounce_thread;
+
+static int barrier_failed;
+static int barrier_done[N_THR];
+
+/* First phase bounces execution between two threads using a condition
+ * variable, continuously testing that no other thread is mucking with
+ * the protected state.  This ends with all threads going back to
+ * sleep on the condition variable and being woken by main() for the
+ * second phase.
+ *
+ * Second phase simply lines up all the threads on a barrier, verifies
+ * that none run until the last one enters, and that all run after the
+ * exit.
+ *
+ * Test success is signaled to main() using a traditional semaphore.
+ */
+
+void *thread_top(void *p1)
+{
+	int i, j, id = (int) p1;
+	int policy;
+	struct sched_param schedparam;
+
+	pthread_getschedparam(pthread_self(), &policy, &schedparam);
+	TC_PRINT("Thread %d starting with scheduling policy %d & priority %d\n",
+		 id, policy, schedparam.priority);
+	/* Try a double-lock here to exercise the failing case of
+	 * trylock.  We don't support RECURSIVE locks, so this is
+	 * guaranteed to fail.
+	 */
+	pthread_mutex_lock(&lock);
+
+	if (!pthread_mutex_trylock(&lock)) {
+		TC_ERROR("pthread_mutex_trylock inexplicably succeeded\n");
+		bounce_failed = 1;
+	}
+
+	pthread_mutex_unlock(&lock);
+
+	for (i = 0; i < BOUNCES; i++) {
+
+		pthread_mutex_lock(&lock);
+
+		/* Wait for the current owner to signal us, unless we
+		 * are the very first thread, in which case we need to
+		 * wait a bit to be sure the other threads get
+		 * scheduled and wait on cvar0.
+		 */
+		if (!(id == 0 && i == 0)) {
+			pthread_cond_wait(&cvar0, &lock);
+		} else {
+			pthread_mutex_unlock(&lock);
+			usleep(500 * USEC_PER_MSEC);
+			pthread_mutex_lock(&lock);
+		}
+
+		/* Claim ownership, then try really hard to give someone
+		 * else a shot at hitting this if they are racing.
+		 */
+		curr_bounce_thread = id;
+		for (j = 0; j < 1000; j++) {
+			if (curr_bounce_thread != id) {
+				TC_ERROR("Racing bounce threads\n");
+				bounce_failed = 1;
+				k_sem_give(&main_sem);
+				pthread_mutex_unlock(&lock);
+				return NULL;
+			}
+			sched_yield();
+		}
+
+		/* Next one's turn, go back to the top and wait.  */
+		pthread_cond_signal(&cvar0);
+		pthread_mutex_unlock(&lock);
+	}
+
+	/* Signal we are complete to main(), then let it wake us up.  Note
+	 * that we are using the same mutex with both cvar0 and cvar1,
+	 * which is non-standard but kosher per POSIX (and it works fine
+	 * in our implementation
+	 */
+	pthread_mutex_lock(&lock);
+	bounce_done[id] = 1;
+	k_sem_give(&main_sem);
+	pthread_cond_wait(&cvar1, &lock);
+	pthread_mutex_unlock(&lock);
+
+	/* Now just wait on the barrier.  Make sure no one else finished
+	 * before we wait on it, then signal that we're done
+	 */
+	for (i = 0; i < N_THR; i++) {
+		if (barrier_done[i]) {
+			TC_ERROR("Barrier exited early\n");
+			barrier_failed = 1;
+			k_sem_give(&main_sem);
+		}
+	}
+	pthread_barrier_wait(&barrier);
+	barrier_done[id] = 1;
+	k_sem_give(&main_sem);
+	pthread_exit(p1);
+
+	return NULL;
+}
+
+int bounce_test_done(void)
+{
+	int i;
+
+	if (bounce_failed) {
+		return 1;
+	}
+
+	for (i = 0; i < N_THR; i++) {
+		if (!bounce_done[i]) {
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+int barrier_test_done(void)
+{
+	int i;
+
+	if (barrier_failed) {
+		return 1;
+	}
+
+	for (i = 0; i < N_THR; i++) {
+		if (!barrier_done[i]) {
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+void main(void)
+{
+	int i, ret, min_prio, max_prio, status = TC_FAIL;
+	pthread_attr_t attr[N_THR];
+	struct sched_param schedparam;
+	pthread_t newthread[N_THR];
+	int schedpolicy = SCHED_FIFO;
+	void *retval;
+
+	TC_START("POSIX thread IPC APIs\n");
+	schedparam.priority = CONFIG_NUM_COOP_PRIORITIES - 1;
+	min_prio = sched_get_priority_min(schedpolicy);
+	max_prio = sched_get_priority_max(schedpolicy);
+
+	if (min_prio < 0 || max_prio < 0 || schedparam.priority < min_prio ||
+	    schedparam.priority > max_prio) {
+		TC_ERROR("Scheduling priority outside valid priority range\n");
+		goto done;
+	}
+
+	for (i = 0; i < N_THR; i++) {
+		ret = pthread_attr_init(&attr[i]);
+		if (ret != 0) {
+			TC_ERROR("Thread attribute initialization failed\n");
+			goto done;
+		}
+		pthread_attr_setstack(&attr[i], &stacks[i][0], STACKSZ);
+		pthread_attr_setschedpolicy(&attr[i], schedpolicy);
+		pthread_attr_setschedparam(&attr[i], &schedparam);
+		ret = pthread_create(&newthread[i], &attr[i], thread_top,
+				     (void *)i);
+
+		if (ret != 0) {
+			TC_ERROR("Number of threads exceeds maximum limit\n");
+			goto done;
+		}
+
+	}
+
+	while (!bounce_test_done()) {
+		k_sem_take(&main_sem, K_FOREVER);
+	}
+
+	if (bounce_failed) {
+		goto done;
+	}
+
+	TC_PRINT("Bounce test OK\n");
+
+	/* Wake up the worker threads */
+	pthread_mutex_lock(&lock);
+	pthread_cond_broadcast(&cvar1);
+	pthread_mutex_unlock(&lock);
+
+	while (!barrier_test_done()) {
+		k_sem_take(&main_sem, K_FOREVER);
+	}
+
+	if (barrier_failed) {
+		goto done;
+	}
+
+	for (i = 0; i < N_THR; i++) {
+		pthread_join(newthread[i], &retval);
+	}
+
+	TC_PRINT("Barrier test OK\n");
+	status = TC_PASS;
+
+ done:
+	TC_END_REPORT(status);
+}

tests/kernel/posix/pthread/testcase.yaml

@@ -0,0 +1,3 @@
+tests:
+  test:
+    tags: core