sched-rr: A round-robin scheduler for normal thread

Makefile

@@ -46,6 +46,7 @@ includes = \
 	board/$(BOARD) \
 	include \
 	include/platform \
+	include/sched-rr \
 	.\
 $(eval BOARD_$(BOARD)=y)
 
@@ -64,6 +65,7 @@ include platform/$(CHIP)/build.mk
 include platform/$(PLATFORM)-common/build.mk
 include platform/build.mk
 include kernel/lib/build.mk
+include kernel/sched-rr/build.mk
 include kernel/build.mk
 include user/build.mk
 include loader/build.mk
@@ -80,6 +82,7 @@ all-y += $(call objs_from_dir,platform/$(PLATFORM)-common,platform-common)
 all-y += $(call objs_from_dir,board/$(BOARD),board)
 all-y += $(call objs_from_dir,platform,platform)
 all-y += $(call objs_from_dir,kernel/lib,kernel-lib)
+all-y += $(call objs_from_dir,kernel/sched-rr,kernel-sched-rr)
 all-y += $(call objs_from_dir,kernel,kernel)
 all-y += $(call objs_from_dir,user,user)
 
@@ -93,6 +96,7 @@ loader-all-y += $(call objs_from_dir,kernel,loader-kernel)
 
 dirs = \
 	kernel/lib \
+	kernel/sched-rr \
 	kernel \
 	platform/$(CHIP) \
 	platform/$(PLATFORM)-common \

board/discoveryf4/defconfig

@@ -46,6 +46,7 @@ CONFIG_SMALLEST_FPAGE_SHIFT=8
 # Thread tweaks
 #
 CONFIG_INTR_THREAD_MAX=256
+CONFIG_THREAD_TIME_SLICE=4096
 
 #
 # KIP tweaks

board/discoveryf429/defconfig

@@ -132,6 +132,7 @@ CONFIG_SMALLEST_FPAGE_SHIFT=8
 # Thread tweaks
 #
 CONFIG_INTR_THREAD_MAX=256
+CONFIG_THREAD_TIME_SLICE=4096
 
 #
 # KIP tweaks

board/stm32p103/defconfig

@@ -94,6 +94,7 @@ CONFIG_SMALLEST_FPAGE_SHIFT=8
 # Thread tweaks
 #
 CONFIG_INTR_THREAD_MAX=256
+CONFIG_THREAD_TIME_SLICE=4096
 
 #
 # KIP tweaks

include/sched-rr/sched_rr.h

@@ -0,0 +1,31 @@
+/* Copyright (c) 2016 The F9 Microkernel Project. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+
+#ifndef SCHED_RR_H_
+#define SCHED_RR_H_
+
+#define MAX_QUEUE (CONFIG_MAX_THREADS + 1)
+#define TIME_SLICE CONFIG_THREAD_TIME_SLICE
+
+typedef struct cqueue {
+	uint32_t Queue[MAX_QUEUE];
+	int front;
+	int rear;
+	int count;
+
+	void (*put)(struct cqueue *q, void *data);
+	void *(*get)(struct cqueue *q);
+	int (*is_empty)(struct cqueue *q);
+	int (*is_full)(struct cqueue *q);
+	int (*length)(struct cqueue *q);
+} cqueue_t;
+
+
+tcb_t *rr_select(void);
+void rr_init_thread(tcb_t *thr);
+uint32_t rr_exhaust_timeslice(void *data);
+
+#endif

include/thread.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2013 The F9 Microkernel Project. All rights reserved.
+/* Copyright (c) 2013, 2016 The F9 Microkernel Project. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
@@ -54,7 +54,9 @@ typedef enum {
 	T_RUNNABLE,
 	T_SVC_BLOCKED,
 	T_RECV_BLOCKED,
-	T_SEND_BLOCKED
+	T_SEND_BLOCKED,
+	T_WAIT_SCHEDULE,	/* Wait to append to scheduler */
+	T_PENDING_SCHED,	/* Wait for execute in scheculer */
 } thread_state_t;
 
 typedef struct {
@@ -95,6 +97,7 @@ struct tcb {
 	struct tcb *t_child;
 
 	uint32_t timeout_event;
+	uint32_t (*timeslice_event)(void *);
 };
 typedef struct tcb tcb_t;
 

kernel/Kconfig

@@ -71,6 +71,10 @@ menu "Thread tweaks"
 config INTR_THREAD_MAX
 	int "Maximum of interrupt threads"
 	default 256
+
+config THREAD_TIME_SLICE
+	int "Maximum timeslice for threads"
+	default 4096
 endmenu
 
 menu "KIP tweaks"

kernel/ipc.c

@@ -1,4 +1,4 @@
-/* Copyright (c) 2013, 2014 The F9 Microkernel Project. All rights reserved.
+/* Copyright (c) 2013, 2014, 2016 The F9 Microkernel Project. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
@@ -16,6 +16,7 @@
 #include <user-log.h>
 #include <ktimer.h>
 #include <interrupt.h>
+#include <sched-rr/sched_rr.h>
 
 extern tcb_t *caller;
 
@@ -241,7 +242,6 @@ void sys_ipc(uint32_t *param1)
 				/* mr1: thread func, mr2: stack addr, mr3: stack size*/
 				/* mr4: thread entry, mr5: thread args */
 				/* thread start protocol */
-
 				memptr_t sp = ipc_read_mr(caller, 2);
 				size_t stack_size = ipc_read_mr(caller, 3);
 				uint32_t regs[4];	/* r0, r1, r2, r3 */
@@ -260,8 +260,11 @@ void sys_ipc(uint32_t *param1)
 
 				caller->state = T_RUNNABLE;
 
-				/* Start thread */
-				to_thr->state = T_RUNNABLE;
+				/* make a timeslice for thread*/
+				dbg_printf(DL_IPC, "IPC: making timeslice for: %x @[%x]\n",
+									to_tid,
+									to_thr);
+				rr_init_thread(to_thr);
 
 				return;
 			} else {

kernel/ktimer.c

@@ -328,6 +328,7 @@ void ktimer_enter_tickless()
 	uint32_t tickless_delta;
 	uint32_t reload;
 
+	dbg_printf(DL_KTIMER, "KTE: Handle ticklesss event\n");
 	irq_disable();
 
 	if (ktimer_enabled && ktimer_delta <= KTIMER_MAXTICKS) {

kernel/sched-rr/build.mk

@@ -0,0 +1,6 @@
+# Copyright (c) 2016 The F9 Microkernel Project. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+kernel-sched-rr-y = \
+	sched_rr.o

kernel/sched-rr/sched_rr.c

@@ -0,0 +1,103 @@
+/* Copyright (c) 2016 The F9 Microkernel Project. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <types.h>
+#include <thread.h>
+#include <ktimer.h>
+#include <sched-rr/sched_rr.h>
+
+void put(cqueue_t *q, void *data)
+{
+	if (!q->is_full(q)) {
+		q->count++;
+		q->rear = (q->rear + 1) % (MAX_QUEUE);
+		q->Queue[q->rear] = (uint32_t) data;
+	}
+}
+
+void *get(cqueue_t *q)
+{
+	uint32_t ret;
+
+	if (!q->is_empty(q)) {
+		q->count--;
+		ret = q->Queue[++q->front % MAX_QUEUE];
+		if (q->front % MAX_QUEUE == 0) {
+			q->front = 0;
+		}
+
+		return (void *) ret;
+	}
+
+	return NULL;
+}
+
+int is_empty(cqueue_t *q)
+{
+	return q->count == 0;
+}
+
+int is_full(cqueue_t *q)
+{
+	return q->count == MAX_QUEUE - 1;
+}
+
+int length(cqueue_t *q)
+{
+	return q->count;
+}
+
+cqueue_t schedQueue = {
+	.Queue = { 0 },
+	.front = -1,
+	.rear = -1,
+	.count = 0,
+	.put = put,
+	.get = get,
+	.is_empty = is_empty,
+	.is_full = is_full,
+	.length = length,
+};
+
+void rr_init_thread(tcb_t *thr)
+{
+	thr->timeslice_event = rr_exhaust_timeslice;
+	thr->state = T_WAIT_SCHEDULE;
+	schedQueue.put(&schedQueue, (void *) thr);
+}
+
+uint32_t rr_exhaust_timeslice(void *data)
+{
+	/* Get thread in data */
+	tcb_t *thr = (tcb_t *) ((ktimer_event_t *)data)->data;
+
+	/* Check thread state to schedule */
+	if (thr->state == T_RUNNABLE) {
+		thr->state = T_WAIT_SCHEDULE;
+		schedQueue.put(&schedQueue, (void *) thr);
+	}
+
+	return 0;
+}
+
+tcb_t *rr_select(void)
+{
+	tcb_t *thr = NULL;
+
+	while (!schedQueue.is_empty(&schedQueue)) {
+		thr = (tcb_t *) schedQueue.get(&schedQueue);
+
+		if (thr->state == T_WAIT_SCHEDULE) {
+			thr->state = T_PENDING_SCHED;
+			schedQueue.put(&schedQueue, (void *) thr);
+		} else if (thr->state == T_PENDING_SCHED) {
+			thr->state = T_RUNNABLE;
+			ktimer_event_create(TIME_SLICE, thr->timeslice_event, thr);
+			return thr;
+		}
+	}
+
+	return NULL;
+}

kernel/thread.c

@@ -1,4 +1,4 @@
-/* Copyright (c) 2013, 2014 The F9 Microkernel Project. All rights reserved.
+/* Copyright (c) 2013, 2014, 2016 The F9 Microkernel Project. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
@@ -12,6 +12,7 @@
 #include <platform/armv7m.h>
 #include <fpage_impl.h>
 #include <init_hook.h>
+#include <sched-rr/sched_rr.h>
 
 /**
  * @file    thread.c
@@ -411,6 +412,9 @@ static tcb_t *thread_select(tcb_t *parent)
 	if (thr == NULL)
 		return NULL;
 
+	if ((thr = rr_select()) != NULL)
+		return thr;
+
 	while (1) {
 		if (thread_isrunnable(thr))
 			return thr;
@@ -467,7 +471,7 @@ void kdb_dump_threads(void)
 	tcb_t *thr;
 	int idx;
 
-	char *state[] = { "FREE", "RUN", "SVC", "RECV", "SEND" };
+	char *state[] = { "FREE", "RUN", "SVC", "RECV", "SEND", "SCHED", "PEND"};
 
 	dbg_printf(DL_KDB, "%5s %8s %8s %6s %s\n",
 	           "type", "global", "local", "state", "parent");