[Cbe-oss-dev] [PATCH 06/10 v2]MARS/core: Workload module split kernel cleanup
Yuji Mano
yuji.mano at am.sony.com
Sat Nov 22 13:02:24 EST 2008
This cleans up the MARS core kernel implementation.
Most of the implementation will be moved into the task module/lib.
The kernel will only be responsible for workload scheduling and loading/running
the appropriate workload module.
Signed-off-by: Yuji Mano <yuji.mano at am.sony.com>
---
v2:
- updated the __stack symbol in Makefile so kernel uses 16K
core/src/common/kernel_internal_types.h | 18 +
core/src/mpu/kernel/Makefile.am | 15 -
core/src/mpu/kernel/kernel.c | 326 +++++++++++++++++++++++++-
core/src/mpu/kernel/kernel.h | 126 ----------
core/src/mpu/kernel/kernel_registers.c | 152 ------------
core/src/mpu/kernel/kernel_scheduler.c | 253 --------------------
core/src/mpu/kernel/kernel_syscalls.c | 190 ---------------
core/src/mpu/kernel/kernel_task.c | 137 -----------
core/src/mpu/kernel/kernel_workload.c | 396 --------------------------------
9 files changed, 343 insertions(+), 1270 deletions(-)
--- a/core/src/common/kernel_internal_types.h
+++ b/core/src/common/kernel_internal_types.h
@@ -40,10 +40,25 @@
#include <stdint.h>
+#define MARS_KERNEL_STATUS_BUSY 0x0
+#define MARS_KERNEL_STATUS_IDLE 0x1
+#define MARS_KERNEL_STATUS_EXIT 0x2
#define MARS_KERNEL_TICKS_FLAG_SYNC_BEGIN 0x1
#define MARS_KERNEL_TICKS_FLAG_SYNC_END 0x2
#define MARS_KERNEL_PARAMS_ALIGN 128
+/* mars kernel syscalls */
+struct mars_kernel_syscalls {
+ void (*module_exit)(uint8_t state);
+ uint64_t (*get_mars_context_ea)(void);
+ uint32_t (*get_kernel_id)(void);
+ uint8_t (*get_workload_type)(void);
+ uint16_t (*get_workload_id)(void);
+ struct mars_workload_context * (*get_workload)(void);
+ struct mars_workload_queue_header *(*get_workload_queue_header)(void);
+ struct mars_workload_queue_block * (*get_workload_queue_block)(void);
+};
+
/* mars kernel ticks */
struct mars_kernel_ticks {
uint32_t flag;
@@ -58,4 +73,7 @@ struct mars_kernel_params {
struct mars_kernel_ticks kernel_ticks;
} __attribute__((aligned(MARS_KERNEL_PARAMS_ALIGN)));
+/* mars module entry */
+void mars_module_entry(struct mars_kernel_syscalls *syscalls);
+
#endif
--- a/core/src/mpu/kernel/Makefile.am
+++ b/core/src/mpu/kernel/Makefile.am
@@ -47,8 +47,7 @@ if DEBUG
else
extra_cppflags += "-DNDEBUG"
# release kernel is 16K
- # ** todo **
- extra_ldflags += -Wl,--defsym=__stack=0x0fff0
+ extra_ldflags += -Wl,--defsym=__stack=0x03ff0
endif
if MARS_PLATFORM_CELL
@@ -89,16 +88,10 @@ AM_LDFLAGS = \
noinst_PROGRAMS = mars_kernel
-mars_kernel_LDADD = $(builddir)/../lib/libmars.a
-
mars_kernel_SOURCES = \
$(srcdir)/../../../src/common/*.h \
- kernel.c \
- kernel.h \
- kernel_registers.c \
- kernel_scheduler.c \
- kernel_syscalls.c \
- kernel_task.c \
- kernel_workload.c
+ kernel.c
+
+mars_kernel_LDADD = $(builddir)/../lib/libmars_core.la
CLEANFILES = *.map
--- a/core/src/mpu/kernel/kernel.c
+++ b/core/src/mpu/kernel/kernel.c
@@ -35,11 +35,326 @@
* LIBRARY OR THE USE OR OTHER DEALINGS IN THE LIBRARY.
*/
-#include "kernel.h"
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "mars/dma.h"
+#include "mars/error.h"
+#include "mars/module.h"
+#include "mars/mutex.h"
+
+#include "kernel_internal_types.h"
+#include "workload_internal_types.h"
+
+#define MARS_WORKLOAD_RESERVED_NONE 0
+#define MARS_WORKLOAD_RESERVED 1
+
+/* kernel */
+void *_kernel_stack;
+static struct mars_kernel_params kernel_params;
+
+/* workload queue */
+static struct mars_workload_queue_header queue_header;
+static struct mars_workload_queue_block queue_block;
+
+/* workload */
+static struct mars_workload_context workload;
+static uint8_t workload_type;
+static uint8_t workload_state;
+static uint16_t workload_id;
+static uint64_t workload_ea;
+
+/* module entry */
+typedef void (*module_entry)(
+ const struct mars_kernel_syscalls *kernel_syscalls);
-struct mars_kernel_params kernel_params;
+static void module_exit(uint8_t state)
+{
+ workload_state = state;
+
+ /* restore kernel stack pointer and goto to exit label */
+ asm volatile (
+ "lqa $sp, _kernel_stack;"
+ "br _module_exit;"
+ );
+}
+
+static uint64_t get_mars_context_ea(void)
+{
+ return kernel_params.mars_context_ea;
+}
+
+static uint32_t get_kernel_id(void)
+{
+ return kernel_params.kernel_id;
+}
+
+static uint8_t get_workload_type(void)
+{
+ return workload_type;
+}
+
+static uint16_t get_workload_id(void)
+{
+ return workload_id;
+}
+
+static struct mars_workload_context *get_workload(void)
+{
+ return &workload;
+}
+
+static struct mars_workload_queue_header *get_workload_queue_header(void)
+{
+ return &queue_header;
+}
+
+static struct mars_workload_queue_block *get_workload_queue_block(void)
+{
+ return &queue_block;
+}
+
+static struct mars_kernel_syscalls kernel_syscalls =
+{
+ module_exit,
+ get_mars_context_ea,
+ get_kernel_id,
+ get_workload_type,
+ get_workload_id,
+ get_workload,
+ get_workload_queue_header,
+ get_workload_queue_block
+};
+
+static void get_block(int block, struct mars_workload_queue_block *dst)
+{
+ mars_dma_get_and_wait(dst,
+ queue_header.queue_ea +
+ offsetof(struct mars_workload_queue, block) +
+ sizeof(struct mars_workload_queue_block) * block,
+ sizeof(struct mars_workload_queue_block),
+ MARS_DMA_TAG);
+}
+
+static int search_block(int block)
+{
+ int i;
+ int index = -1;
+ uint16_t max_counter = 0;
+ uint16_t max_priority = 0;
+
+ /* search through workload queue for next workload to run
+ * while incrementing wait counter for all waiting workloads
+ * and pick the workload that has been waiting the longest
+ */
+ for (i = 0; i < MARS_WORKLOAD_PER_BLOCK; i++) {
+ uint64_t *bits = &queue_block.bits[i];
+ uint8_t signal = MARS_BITS_GET(bits, SIGNAL);
+ uint8_t priority = MARS_BITS_GET(bits, PRIORITY);
+ uint16_t wait_id = MARS_BITS_GET(bits, WAIT_ID);
+ uint16_t counter = MARS_BITS_GET(bits, COUNTER);
+
+ switch (MARS_BITS_GET(bits, STATE)) {
+ case MARS_WORKLOAD_STATE_READY:
+ /* compare priority and counter with previous ones */
+ if (index < 0 || priority > max_priority ||
+ (priority == max_priority && counter > max_counter)) {
+ index = i;
+ max_counter = counter;
+ max_priority = priority;
+ }
+ /* increment wait counter without overflowing */
+ if (counter < MARS_WORKLOAD_COUNTER_MAX)
+ MARS_BITS_SET(bits, COUNTER, counter + 1);
+ break;
+ case MARS_WORKLOAD_STATE_WAITING:
+ /* waiting for workload to finish so check status */
+ if (wait_id != MARS_WORKLOAD_ID_NONE) {
+ struct mars_workload_queue_block wait_block;
+ struct mars_workload_queue_block *p_wait_block;
+ uint8_t wait_state;
+
+ int bl = wait_id / MARS_WORKLOAD_PER_BLOCK;
+ int id = wait_id % MARS_WORKLOAD_PER_BLOCK;
+
+ /* check if workload id is in the same block */
+ if (block != bl) {
+ /* fetch the necessary block */
+ get_block(bl, &wait_block);
+ /* set pointer to check fetched block */
+ p_wait_block = &wait_block;
+ } else {
+ /* set pointer to check current block */
+ p_wait_block = &queue_block;
+ }
+
+ wait_state =
+ MARS_BITS_GET(&p_wait_block->bits[id],
+ STATE);
+
+ /* check if workload is finished and reset */
+ if (wait_state ==
+ MARS_WORKLOAD_STATE_FINISHED) {
+ MARS_BITS_SET(bits, WAIT_ID,
+ MARS_WORKLOAD_ID_NONE);
+ MARS_BITS_SET(bits, STATE,
+ MARS_WORKLOAD_STATE_READY);
+ }
+ /* waiting for signal so check signal bit and reset */
+ } else if (signal == MARS_WORKLOAD_SIGNAL_ON) {
+ MARS_BITS_SET(bits, SIGNAL,
+ MARS_WORKLOAD_SIGNAL_OFF);
+ MARS_BITS_SET(bits, STATE,
+ MARS_WORKLOAD_STATE_READY);
+ i--;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ /* returns -1 if no runnable workload found */
+ return index;
+}
+
+static int reserve_block(int block)
+{
+ int index;
+ uint64_t block_ea;
+
+ /* calculate block ea */
+ block_ea = queue_header.queue_ea +
+ offsetof(struct mars_workload_queue, block) +
+ sizeof(struct mars_workload_queue_block) * block;
+
+ mars_mutex_lock_get(block_ea, (struct mars_mutex *)&queue_block);
+
+ /* set the workload index */
+ index = search_block(block);
+ if (index >= 0) {
+ /* update the current state of the workload */
+ MARS_BITS_SET(&queue_block.bits[index], STATE,
+ MARS_WORKLOAD_STATE_RUNNING);
+
+ /* reset the counter for reserved workload */
+ MARS_BITS_SET(&queue_block.bits[index], COUNTER,
+ MARS_WORKLOAD_COUNTER_MIN);
+ }
+
+ mars_mutex_unlock_put(block_ea, (struct mars_mutex *)&queue_block);
+
+ return index;
+}
+
+static void release_block(int block, int index)
+{
+ uint64_t block_ea = queue_header.queue_ea +
+ offsetof(struct mars_workload_queue, block) +
+ sizeof(struct mars_workload_queue_block) * block;
+
+ mars_mutex_lock_get(block_ea, (struct mars_mutex *)&queue_block);
+
+ /* update current workload state in workload queue block */
+ MARS_BITS_SET(&queue_block.bits[index], STATE, workload_state);
+
+ mars_mutex_unlock_put(block_ea, (struct mars_mutex *)&queue_block);
+}
+
+static int __attribute__((noinline)) reserve_workload(void)
+{
+ int block;
+ int index = -1;
+
+ /* search workload queue blocks until runnable workload reserved */
+ for (block = 0; block < MARS_WORKLOAD_NUM_BLOCKS; block++) {
+ index = reserve_block(block);
+ if (index >= 0)
+ break;
+ }
+
+ /* no runnable workload found */
+ if (index < 0)
+ return MARS_WORKLOAD_RESERVED_NONE;
+
+ /* set global workload info based on workload block and index */
+ workload_type = MARS_BITS_GET(&queue_block.bits[index], TYPE);
+ workload_id = MARS_WORKLOAD_PER_BLOCK * block + index;
+ workload_ea = queue_header.context_ea +
+ workload_id * sizeof(struct mars_workload_context);
+
+ /* get the workload context code from workload queue */
+ mars_dma_get_and_wait(&workload, workload_ea,
+ sizeof(struct mars_workload_context), MARS_DMA_TAG);
+
+ return MARS_WORKLOAD_RESERVED;
+}
+
+static void __attribute__((noinline)) release_workload(void)
+{
+ int block = workload_id / MARS_WORKLOAD_PER_BLOCK;
+ int index = workload_id % MARS_WORKLOAD_PER_BLOCK;
+
+ /* put the workload context into workload queue */
+ mars_dma_put_and_wait(&workload, workload_ea,
+ sizeof(struct mars_workload_context), MARS_DMA_TAG);
+
+ /* release block reservation */
+ release_block(block, index);
+}
+
+static int __attribute__((noinline)) scheduler(void)
+{
+ int status;
+
+ /* get the workload queue header */
+ mars_dma_get_and_wait(&queue_header,
+ kernel_params.workload_queue_ea +
+ offsetof(struct mars_workload_queue, header),
+ sizeof(struct mars_workload_queue_header),
+ MARS_DMA_TAG);
+
+ /* return exit status if exit flag is set from host */
+ if (queue_header.flag == MARS_WORKLOAD_QUEUE_FLAG_EXIT)
+ return MARS_KERNEL_STATUS_EXIT;
+
+ /* reserve next workload to run or return idle status if none found */
+ status = reserve_workload();
+
+ /* return idle status if no workload was reserved */
+ if (status == MARS_WORKLOAD_RESERVED_NONE)
+ return MARS_KERNEL_STATUS_IDLE;
+
+ /* load the exec code into mpu storage from host storage */
+ mars_dma_large_get_and_wait((void *)MARS_WORKLOAD_MODULE_ELF_VADDR,
+ workload.module.exec_ea, workload.module.exec_size,
+ MARS_DMA_TAG);
+
+ /* 0 the bss section */
+ memset((void *)MARS_WORKLOAD_MODULE_ELF_VADDR +
+ workload.module.exec_size, 0, workload.module.bss_size);
+
+ /* save kernel stack pointer */
+ asm volatile (
+ "stqa $sp, _kernel_stack;"
+ );
+
+ /* call module entry function */
+ ((module_entry)workload.module.entry)(&kernel_syscalls);
+
+ /* label so module can jump back here at exit */
+ asm volatile (
+ "_module_exit:"
+ );
+
+ /* release reservation of current workload */
+ release_workload();
+
+ return MARS_KERNEL_STATUS_BUSY;
+}
-static void kernel_get_params(uint64_t kernel_params_ea)
+static void get_params(uint64_t kernel_params_ea)
{
int mask;
@@ -91,13 +406,14 @@ static void kernel_get_params(uint64_t k
spu_write_event_ack(MFC_LLR_LOST_EVENT);
}
-int main(unsigned long long mpu_context_id, unsigned long long kernel_params_ea)
+int main(unsigned long long mpu_context_id,
+ unsigned long long kernel_params_ea)
{
(void)mpu_context_id;
int exit_flag = 0;
- kernel_get_params(kernel_params_ea);
+ get_params(kernel_params_ea);
while (!exit_flag) {
int status = scheduler();
--- a/core/src/mpu/kernel/kernel.h
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright 2008 Sony Corporation of America
- *
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this Library and associated documentation files (the
- * "Library"), to deal in the Library without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Library, and to
- * permit persons to whom the Library is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Library.
- *
- * If you modify the Library, you may copy and distribute your modified
- * version of the Library in object code or as an executable provided
- * that you also do one of the following:
- *
- * Accompany the modified version of the Library with the complete
- * corresponding machine-readable source code for the modified version
- * of the Library; or,
- *
- * Accompany the modified version of the Library with a written offer
- * for a complete machine-readable copy of the corresponding source
- * code of the modified version of the Library.
- *
- *
- * THE LIBRARY IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * LIBRARY OR THE USE OR OTHER DEALINGS IN THE LIBRARY.
- */
-
-#ifndef MARS_KERNEL_H
-#define MARS_KERNEL_H
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stddef.h>
-
-#include "mars/mutex.h"
-#include "mars/error.h"
-#include "mars/task_types.h"
-
-#include "kernel_internal_types.h"
-#include "mutex_internal_types.h"
-#include "workload_internal_types.h"
-#include "task_internal_types.h"
-#include "syscalls.h"
-#include "dma.h"
-
-#define MARS_KERNEL_STATUS_BUSY 0x0
-#define MARS_KERNEL_STATUS_IDLE 0x1
-#define MARS_KERNEL_STATUS_EXIT 0x2
-
-typedef void (*mars_entry)(void *workload_args, void *kernel_syscalls);
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-void mars_reentry(void);
-
-/* kernel scheduler function */
-int scheduler(void);
-
-/* kernel syscall functions */
-uint32_t syscall_get_ticks(void);
-uint64_t syscall_get_mars_context_ea(void);
-uint32_t syscall_get_kernel_id(void);
-uint16_t syscall_get_workload_id(void);
-uint64_t syscall_get_workload_ea(void);
-struct mars_workload_context *syscall_get_workload(void);
-struct mars_workload_context *syscall_get_workload_by_id(uint16_t workload_id);
-
-void syscall_init(void);
-void syscall_exit(void);
-void syscall_yield(void);
-void syscall_resume(void);
-int syscall_schedule(uint16_t workload_id, void *args, uint8_t priority);
-int syscall_wait(uint16_t workload_id);
-int syscall_try_wait(uint16_t workload_id);
-int syscall_signal_send(uint16_t workload_id);
-void syscall_signal_wait(void);
-int syscall_signal_try_wait(void);
-
-/* register saving / restoring functions */
-void registers_save(void);
-void registers_restore(void);
-
-/* workload specific functions */
-uint16_t workload_get_id(void);
-uint64_t workload_get_ea(void);
-struct mars_workload_context *workload_get(void);
-struct mars_workload_context *workload_get_by_id(uint16_t workload_id);
-
-void workload_exec(void);
-void workload_exit(void);
-void workload_yield(void);
-void workload_resume(void);
-int workload_schedule(uint16_t workload_id, void *args, uint8_t priority);
-int workload_wait(uint16_t workload_id);
-int workload_try_wait(uint16_t workload_id);
-int workload_signal_send(uint16_t workload_id);
-void workload_signal_wait(void);
-int workload_signal_try_wait(void);
-
-/* task specific functions */
-void task_exec(struct mars_task_context *task);
-void task_exit(struct mars_task_context *task);
-void task_yield(struct mars_task_context *task);
-void task_resume(struct mars_task_context *task);
-void task_schedule(struct mars_task_context *task, struct mars_task_args *args);
-
-extern struct mars_kernel_params kernel_params;
-extern struct mars_kernel_syscalls kernel_syscalls;
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif
--- a/core/src/mpu/kernel/kernel_registers.c
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright 2008 Sony Corporation of America
- *
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this Library and associated documentation files (the
- * "Library"), to deal in the Library without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Library, and to
- * permit persons to whom the Library is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Library.
- *
- * If you modify the Library, you may copy and distribute your modified
- * version of the Library in object code or as an executable provided
- * that you also do one of the following:
- *
- * Accompany the modified version of the Library with the complete
- * corresponding machine-readable source code for the modified version
- * of the Library; or,
- *
- * Accompany the modified version of the Library with a written offer
- * for a complete machine-readable copy of the corresponding source
- * code of the modified version of the Library.
- *
- *
- * THE LIBRARY IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * LIBRARY OR THE USE OR OTHER DEALINGS IN THE LIBRARY.
- */
-
-#include "kernel.h"
-
-void registers_save(void)
-{
- /* push non-volatile registers on to the workload stack */
- asm volatile (
- "lqa $75, workload_stack;"
-
- "stqd $80, -16($75);"
- "stqd $81, -32($75);"
- "stqd $82, -48($75);"
- "stqd $83, -64($75);"
- "stqd $84, -80($75);"
- "stqd $85, -96($75);"
- "stqd $86, -112($75);"
- "stqd $87, -128($75);"
- "stqd $88, -144($75);"
- "stqd $89, -160($75);"
- "stqd $90, -176($75);"
- "stqd $91, -192($75);"
- "stqd $92, -208($75);"
- "stqd $93, -224($75);"
- "stqd $94, -240($75);"
- "stqd $95, -256($75);"
- "stqd $96, -272($75);"
- "stqd $97, -288($75);"
- "stqd $98, -304($75);"
- "stqd $99, -320($75);"
- "stqd $100, -336($75);"
- "stqd $101, -352($75);"
- "stqd $102, -368($75);"
- "stqd $103, -384($75);"
- "stqd $104, -400($75);"
- "stqd $105, -416($75);"
- "stqd $106, -432($75);"
- "stqd $107, -448($75);"
- "stqd $108, -464($75);"
- "stqd $109, -480($75);"
- "stqd $110, -496($75);"
- "stqd $111, -512($75);"
- "stqd $112, -528($75);"
- "stqd $113, -544($75);"
- "stqd $114, -560($75);"
- "stqd $115, -576($75);"
- "stqd $116, -592($75);"
- "stqd $117, -608($75);"
- "stqd $118, -624($75);"
- "stqd $119, -640($75);"
- "stqd $120, -656($75);"
- "stqd $121, -672($75);"
- "stqd $122, -688($75);"
- "stqd $123, -704($75);"
- "stqd $124, -720($75);"
- "stqd $125, -736($75);"
- "stqd $126, -752($75);"
- "stqd $127, -768($75);"
- );
-}
-
-void registers_restore(void)
-{
- /* pop non-volatile registers from saved workload stack */
- asm volatile (
- "lqa $75, workload_stack;"
-
- "lqd $80, -16($75);"
- "lqd $81, -32($75);"
- "lqd $82, -48($75);"
- "lqd $83, -64($75);"
- "lqd $84, -80($75);"
- "lqd $85, -96($75);"
- "lqd $86, -112($75);"
- "lqd $87, -128($75);"
- "lqd $88, -144($75);"
- "lqd $89, -160($75);"
- "lqd $90, -176($75);"
- "lqd $91, -192($75);"
- "lqd $92, -208($75);"
- "lqd $93, -224($75);"
- "lqd $94, -240($75);"
- "lqd $95, -256($75);"
- "lqd $96, -272($75);"
- "lqd $97, -288($75);"
- "lqd $98, -304($75);"
- "lqd $99, -320($75);"
- "lqd $100, -336($75);"
- "lqd $101, -352($75);"
- "lqd $102, -368($75);"
- "lqd $103, -384($75);"
- "lqd $104, -400($75);"
- "lqd $105, -416($75);"
- "lqd $106, -432($75);"
- "lqd $107, -448($75);"
- "lqd $108, -464($75);"
- "lqd $109, -480($75);"
- "lqd $110, -496($75);"
- "lqd $111, -512($75);"
- "lqd $112, -528($75);"
- "lqd $113, -544($75);"
- "lqd $114, -560($75);"
- "lqd $115, -576($75);"
- "lqd $116, -592($75);"
- "lqd $117, -608($75);"
- "lqd $118, -624($75);"
- "lqd $119, -640($75);"
- "lqd $120, -656($75);"
- "lqd $121, -672($75);"
- "lqd $122, -688($75);"
- "lqd $123, -704($75);"
- "lqd $124, -720($75);"
- "lqd $125, -736($75);"
- "lqd $126, -752($75);"
- "lqd $127, -768($75);"
- );
-}
--- a/core/src/mpu/kernel/kernel_scheduler.c
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- * Copyright 2008 Sony Corporation of America
- *
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this Library and associated documentation files (the
- * "Library"), to deal in the Library without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Library, and to
- * permit persons to whom the Library is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Library.
- *
- * If you modify the Library, you may copy and distribute your modified
- * version of the Library in object code or as an executable provided
- * that you also do one of the following:
- *
- * Accompany the modified version of the Library with the complete
- * corresponding machine-readable source code for the modified version
- * of the Library; or,
- *
- * Accompany the modified version of the Library with a written offer
- * for a complete machine-readable copy of the corresponding source
- * code of the modified version of the Library.
- *
- *
- * THE LIBRARY IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * LIBRARY OR THE USE OR OTHER DEALINGS IN THE LIBRARY.
- */
-
-#include "kernel.h"
-
-#define MARS_WORKLOAD_RESERVED_NONE 0
-#define MARS_WORKLOAD_RESERVED 1
-
-struct mars_workload_queue_header queue_header;
-struct mars_workload_queue_block queue_block;
-struct mars_workload_context workload;
-uint8_t workload_type;
-uint8_t workload_state;
-uint16_t workload_index;
-uint64_t workload_ea;
-
-static inline void get_block(int block, struct mars_workload_queue_block *dst)
-{
- mars_dma_get_and_wait(dst,
- queue_header.queue_ea +
- offsetof(struct mars_workload_queue, block) +
- sizeof(struct mars_workload_queue_block) * block,
- sizeof(struct mars_workload_queue_block),
- MARS_DMA_TAG);
-}
-
-static int search_block(int block)
-{
- int i;
- int index = -1;
- uint16_t max_counter = 0;
- uint16_t max_priority = 0;
-
- /* search through workload queue for next workload to run
- * while incrementing wait counter for all waiting workloads
- * and pick the workload that has been waiting the longest
- */
- for (i = 0; i < MARS_WORKLOAD_PER_BLOCK; i++) {
- uint64_t *bits = &queue_block.bits[i];
- uint8_t signal = MARS_BITS_GET(bits, SIGNAL);
- uint8_t priority = MARS_BITS_GET(bits, PRIORITY);
- uint16_t wait_id = MARS_BITS_GET(bits, WAIT_ID);
- uint16_t counter = MARS_BITS_GET(bits, COUNTER);
-
- switch (MARS_BITS_GET(bits, STATE)) {
- case MARS_WORKLOAD_STATE_READY:
- /* compare priority and counter with previous ones */
- if (index < 0 || priority > max_priority ||
- (priority == max_priority && counter > max_counter)) {
- index = i;
- max_counter = counter;
- max_priority = priority;
- }
- /* increment wait counter without overflowing */
- if (counter < MARS_WORKLOAD_COUNTER_MAX)
- MARS_BITS_SET(bits, COUNTER, counter + 1);
- break;
- case MARS_WORKLOAD_STATE_WAITING:
- /* waiting for workload to finish so check status */
- if (wait_id != MARS_WORKLOAD_ID_NONE) {
- struct mars_workload_queue_block wait_block;
- struct mars_workload_queue_block *p_wait_block;
- uint8_t wait_state;
-
- int bl = wait_id / MARS_WORKLOAD_PER_BLOCK;
- int id = wait_id % MARS_WORKLOAD_PER_BLOCK;
-
- /* check if workload id is in the same block */
- if (block != bl) {
- /* fetch the necessary block */
- get_block(bl, &wait_block);
- /* set pointer to check fetched block */
- p_wait_block = &wait_block;
- } else {
- /* set pointer to check current block */
- p_wait_block = &queue_block;
- }
-
- wait_state =
- MARS_BITS_GET(&p_wait_block->bits[id],
- STATE);
-
- /* check if workload is finished and reset */
- if (wait_state ==
- MARS_WORKLOAD_STATE_FINISHED) {
- MARS_BITS_SET(bits, WAIT_ID,
- MARS_WORKLOAD_ID_NONE);
- MARS_BITS_SET(bits, STATE,
- MARS_WORKLOAD_STATE_READY);
- }
- /* waiting for signal so check signal bit and reset */
- } else if (signal == MARS_WORKLOAD_SIGNAL_ON) {
- MARS_BITS_SET(bits, SIGNAL,
- MARS_WORKLOAD_SIGNAL_OFF);
- MARS_BITS_SET(bits, STATE,
- MARS_WORKLOAD_STATE_READY);
- i--;
- }
- break;
- default:
- break;
- }
- }
-
- /* returns -1 if no runnable workload found */
- return index;
-}
-
-static int reserve_block(int block)
-{
- int index;
- uint64_t block_ea = queue_header.queue_ea +
- offsetof(struct mars_workload_queue, block) +
- sizeof(struct mars_workload_queue_block) * block;
-
- mars_mutex_lock_get(block_ea, (struct mars_mutex *)&queue_block);
-
- /* set the workload index */
- index = search_block(block);
- if (index >= 0) {
- /* update the current state of the workload */
- MARS_BITS_SET(&queue_block.bits[index], STATE,
- MARS_WORKLOAD_STATE_RUNNING);
-
- /* reset the counter for reserved workload */
- MARS_BITS_SET(&queue_block.bits[index], COUNTER,
- MARS_WORKLOAD_COUNTER_MIN);
- }
-
- mars_mutex_unlock_put(block_ea, (struct mars_mutex *)&queue_block);
-
- return index;
-}
-
-static void release_block(int block, int index)
-{
- uint64_t block_ea = queue_header.queue_ea +
- offsetof(struct mars_workload_queue, block) +
- sizeof(struct mars_workload_queue_block) * block;
-
- mars_mutex_lock_get(block_ea, (struct mars_mutex *)&queue_block);
-
- /* update current workload state in workload queue block */
- MARS_BITS_SET(&queue_block.bits[index], STATE, workload_state);
-
- mars_mutex_unlock_put(block_ea, (struct mars_mutex *)&queue_block);
-}
-
-static int __attribute__((noinline)) reserve_workload(void)
-{
- int block;
- int index = -1;
-
- /* search workload queue blocks until runnable workload reserved */
- for (block = 0; block < MARS_WORKLOAD_NUM_BLOCKS; block++) {
- index = reserve_block(block);
- if (index >= 0)
- break;
- }
-
- /* no runnable workload found */
- if (index < 0)
- return MARS_WORKLOAD_RESERVED_NONE;
-
- /* set global workload info based on workload block and index */
- workload_index = MARS_WORKLOAD_PER_BLOCK * block + index;
- workload_type = MARS_BITS_GET(&queue_block.bits[index], TYPE);
- workload_ea = queue_header.context_ea +
- workload_index * sizeof(struct mars_workload_context);
-
- /* dma the workload context code into LS from main memory */
- mars_dma_get_and_wait(&workload, workload_ea,
- sizeof(struct mars_workload_context), MARS_DMA_TAG);
-
- return MARS_WORKLOAD_RESERVED;
-}
-
-static void __attribute__((noinline)) release_workload(void)
-{
- int block = workload_index / MARS_WORKLOAD_PER_BLOCK;
- int index = workload_index % MARS_WORKLOAD_PER_BLOCK;
-
- mars_dma_put_and_wait(&workload, workload_ea,
- sizeof(struct mars_workload_context), MARS_DMA_TAG);
-
- /* release block reservation */
- release_block(block, index);
-}
-
-int scheduler(void)
-{
- int status;
-
- /* dma in queue header */
- mars_dma_get_and_wait(&queue_header,
- kernel_params.workload_queue_ea +
- offsetof(struct mars_workload_queue, header),
- sizeof(struct mars_workload_queue_header),
- MARS_DMA_TAG);
-
- /* return exit status if exit flag is set from host */
- if (queue_header.flag == MARS_WORKLOAD_QUEUE_FLAG_EXIT)
- return MARS_KERNEL_STATUS_EXIT;
-
- /* reserve next workload to run or return idle status if none found */
- status = reserve_workload();
-
- /* return idle status if no workload was reserved */
- if (status == MARS_WORKLOAD_RESERVED_NONE)
- return MARS_KERNEL_STATUS_IDLE;
-
- /* execute the reserved workload */
- workload_exec();
-
- /* release reservation of current workload */
- release_workload();
-
- return MARS_KERNEL_STATUS_BUSY;
-}
--- a/core/src/mpu/kernel/kernel_syscalls.c
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright 2008 Sony Corporation of America
- *
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this Library and associated documentation files (the
- * "Library"), to deal in the Library without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Library, and to
- * permit persons to whom the Library is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Library.
- *
- * If you modify the Library, you may copy and distribute your modified
- * version of the Library in object code or as an executable provided
- * that you also do one of the following:
- *
- * Accompany the modified version of the Library with the complete
- * corresponding machine-readable source code for the modified version
- * of the Library; or,
- *
- * Accompany the modified version of the Library with a written offer
- * for a complete machine-readable copy of the corresponding source
- * code of the modified version of the Library.
- *
- *
- * THE LIBRARY IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * LIBRARY OR THE USE OR OTHER DEALINGS IN THE LIBRARY.
- */
-
-#include "kernel.h"
-
-void *kernel_stack;
-void *workload_stack;
-
-struct mars_kernel_syscalls kernel_syscalls =
-{
- syscall_get_ticks,
- syscall_get_mars_context_ea,
- syscall_get_kernel_id,
- syscall_get_workload_id,
- syscall_get_workload_ea,
- syscall_get_workload,
- syscall_get_workload_by_id,
- syscall_init,
- syscall_exit,
- syscall_yield,
- syscall_schedule,
- syscall_wait,
- syscall_try_wait,
- syscall_signal_send,
- syscall_signal_wait,
- syscall_signal_try_wait
-};
-
-void mars_reentry(void)
-{
- syscall_resume();
-}
-
-uint32_t syscall_get_ticks(void)
-{
- return kernel_params.kernel_ticks.offset - spu_read_decrementer();
-}
-
-uint64_t syscall_get_mars_context_ea(void)
-{
- return kernel_params.mars_context_ea;
-}
-
-uint32_t syscall_get_kernel_id(void)
-{
- return kernel_params.kernel_id;
-}
-
-uint16_t syscall_get_workload_id(void)
-{
- return workload_get_id();
-}
-
-uint64_t syscall_get_workload_ea(void)
-{
- return workload_get_ea();
-}
-
-struct mars_workload_context *syscall_get_workload(void)
-{
- return workload_get();
-}
-
-struct mars_workload_context *syscall_get_workload_by_id(uint16_t workload_id)
-{
- return workload_get_by_id(workload_id);
-}
-
-void syscall_init(void)
-{
- /* save the kernel stack
- **
- ** We need to offset the stack pointer we want to save so that we
- ** return back to the caller of mars_entry and not the caller of
- ** the syscall mars_init and when mars_exit is called and pops the
- ** stack. But we don't want to modify the stack pointer directly
- ** just yet so we can return back to the current caller (mars_entry)
- ** so use a volatile register to do the offset.
- ** NO FUNCTION CALLS OR STACK PUSHES ALLOWED IN HERE.
- */
- asm volatile (
- "ai $75, $sp, 32;"
- "stqa $75, kernel_stack;"
- );
-}
-
-void syscall_exit(void)
-{
- /* restore kernel stack */
- asm volatile (
- "lqa $sp, kernel_stack;"
- );
-
- /* exit current workload */
- workload_exit();
-}
-
-void syscall_yield(void)
-{
- /* save workload stack and restore kernel stack */
- asm volatile (
- "stqa $sp, workload_stack;"
- "lqa $sp, kernel_stack;"
- );
-
- /* yield current workload */
- workload_yield();
-}
-
-void syscall_resume(void)
-{
- /* resume current workload */
- workload_resume();
-
- /* save kernel stack and restore workload stack */
- asm volatile (
- "stqa $sp, kernel_stack;"
- "lqa $sp, workload_stack;"
- );
-}
-
-int syscall_schedule(uint16_t workload_id, void *args, uint8_t priority)
-{
- return workload_schedule(workload_id, args, priority);
-}
-
-int syscall_wait(uint16_t workload_id)
-{
- return workload_wait(workload_id);
-}
-
-int syscall_try_wait(uint16_t workload_id)
-{
- return workload_try_wait(workload_id);
-}
-
-int syscall_signal_send(uint16_t workload_id)
-{
- return workload_signal_send(workload_id);
-}
-
-void syscall_signal_wait(void)
-{
- /* save workload stack and restore kernel stack */
- asm volatile (
- "stqa $sp, workload_stack;"
- "lqa $sp, kernel_stack;"
- );
-
- workload_signal_wait();
-}
-
-int syscall_signal_try_wait(void)
-{
- return workload_signal_try_wait();
-}
--- a/core/src/mpu/kernel/kernel_task.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright 2008 Sony Corporation of America
- *
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this Library and associated documentation files (the
- * "Library"), to deal in the Library without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Library, and to
- * permit persons to whom the Library is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Library.
- *
- * If you modify the Library, you may copy and distribute your modified
- * version of the Library in object code or as an executable provided
- * that you also do one of the following:
- *
- * Accompany the modified version of the Library with the complete
- * corresponding machine-readable source code for the modified version
- * of the Library; or,
- *
- * Accompany the modified version of the Library with a written offer
- * for a complete machine-readable copy of the corresponding source
- * code of the modified version of the Library.
- *
- *
- * THE LIBRARY IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * LIBRARY OR THE USE OR OTHER DEALINGS IN THE LIBRARY.
- */
-
-#include <string.h>
-
-#include "kernel.h"
-
-extern void *workload_stack;
-
-void task_exec(struct mars_task_context *task)
-{
- if (!task->stack) {
- /* dma the exec code into mpu storage from host storage */
- mars_dma_large_get_and_wait((void *)task->vaddr,
- task->exec_ea, task->exec_size, MARS_DMA_TAG);
-
- /* 0 the bss section */
- memset((void *)task->vaddr + task->exec_size, 0,
- task->bss_size);
-
- /* call entry function */
- ((mars_entry)task->entry)(&task->args, &kernel_syscalls);
- } else {
- mars_reentry();
- }
-}
-
-void task_exit(struct mars_task_context *task)
-{
- (void)task;
-}
-
-void task_yield(struct mars_task_context *task)
-{
- struct mars_task_context_save_unit
- list[MARS_TASK_CONTEXT_SAVE_UNIT_MAX];
- int i, offset = 0;
-
- /* save workload stack pointer */
- task->stack = (uint32_t)workload_stack;
-
- /* dma get context save unit list */
- mars_dma_get_and_wait(list, task->context_save_unit_ea,
- MARS_TASK_CONTEXT_SAVE_UNIT_SIZE *
- MARS_TASK_CONTEXT_SAVE_UNIT_MAX, MARS_DMA_TAG);
-
- /* loop through save unit list */
- for (i = 0; i < MARS_TASK_CONTEXT_SAVE_UNIT_MAX; i++) {
- /* list terminator so exit loop */
- if (!list[i].size)
- break;
-
- /* request dma put of the context save unit specified */
- mars_dma_large_put((void *)(task->vaddr + list[i].addr),
- task->context_save_area_ea + offset,
- list[i].size, MARS_DMA_TAG);
-
- offset += list[i].size;
- }
-
- /* wait for all dmas to complete */
- mars_dma_wait(MARS_DMA_TAG);
-}
-
-void task_resume(struct mars_task_context *task)
-{
- struct mars_task_context_save_unit
- list[MARS_TASK_CONTEXT_SAVE_UNIT_MAX];
- int i, offset = 0;
-
- /* restore workload stack pointer */
- workload_stack = (void *)task->stack;
-
- /* dma save get context save unit list */
- mars_dma_get_and_wait(list, task->context_save_unit_ea,
- MARS_TASK_CONTEXT_SAVE_UNIT_SIZE *
- MARS_TASK_CONTEXT_SAVE_UNIT_MAX, MARS_DMA_TAG);
-
- /* loop through save unit list */
- for (i = 0; i < MARS_TASK_CONTEXT_SAVE_UNIT_MAX; i++) {
- /* list terminator so exit loop */
- if (!list[i].size)
- break;
-
- /* request dma get of the context save unit specified */
- mars_dma_large_get((void *)(task->vaddr + list[i].addr),
- task->context_save_area_ea + offset,
- list[i].size, MARS_DMA_TAG);
-
- offset += list[i].size;
- }
-
- /* wait for all dmas to complete */
- mars_dma_wait(MARS_DMA_TAG);
-}
-
-void task_schedule(struct mars_task_context *task, struct mars_task_args *args)
-{
- /* initialize task specific context variables */
- task->stack = 0;
- if (args)
- memcpy(&task->args, args, sizeof(struct mars_task_args));
-}
--- a/core/src/mpu/kernel/kernel_workload.c
+++ /dev/null
@@ -1,396 +0,0 @@
-/*
- * Copyright 2008 Sony Corporation of America
- *
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this Library and associated documentation files (the
- * "Library"), to deal in the Library without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Library, and to
- * permit persons to whom the Library is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Library.
- *
- * If you modify the Library, you may copy and distribute your modified
- * version of the Library in object code or as an executable provided
- * that you also do one of the following:
- *
- * Accompany the modified version of the Library with the complete
- * corresponding machine-readable source code for the modified version
- * of the Library; or,
- *
- * Accompany the modified version of the Library with a written offer
- * for a complete machine-readable copy of the corresponding source
- * code of the modified version of the Library.
- *
- *
- * THE LIBRARY IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * LIBRARY OR THE USE OR OTHER DEALINGS IN THE LIBRARY.
- */
-
-#include "kernel.h"
-
-extern struct mars_workload_queue_header queue_header;
-extern struct mars_workload_queue_block queue_block;
-extern struct mars_workload_context workload;
-extern uint8_t workload_type;
-extern uint8_t workload_state;
-extern uint16_t workload_index;
-extern uint64_t workload_ea;
-
-uint16_t workload_get_id(void)
-{
- return workload_index;
-}
-
-uint64_t workload_get_ea(void)
-{
- return workload_ea;
-}
-
-struct mars_workload_context *workload_get(void)
-{
- return &workload;
-}
-
-struct mars_workload_context *workload_get_by_id(uint16_t workload_id)
-{
- static struct mars_workload_context requested_workload;
- uint64_t requested_workload_ea;
-
- /* check function params */
- if (workload_id >= MARS_WORKLOAD_MAX)
- return NULL;
-
- /* workload id is same as current workload so return local copy */
- if (workload_id == workload_index)
- return &workload;
-
- /* get ea of workload to get */
- requested_workload_ea = queue_header.context_ea +
- workload_id * sizeof(struct mars_workload_context);
-
- /* dma the workload context code into LS from main memory */
- mars_dma_get_and_wait((void *)&requested_workload,
- requested_workload_ea, sizeof(struct mars_workload_context),
- MARS_DMA_TAG);
-
- return &requested_workload;
-}
-
-void workload_exec(void)
-{
- /* set current workload state to running */
- workload_state = MARS_WORKLOAD_STATE_RUNNING;
-
- /* workload type specific handling */
- switch (workload_type) {
- case MARS_WORKLOAD_TYPE_TASK:
- task_exec((struct mars_task_context *)&workload);
- break;
- }
-}
-
-void workload_exit(void)
-{
- /* set current workload state to finished */
- workload_state = MARS_WORKLOAD_STATE_FINISHED;
-
- /* workload type specific handling */
- switch (workload_type) {
- case MARS_WORKLOAD_TYPE_TASK:
- task_exit((struct mars_task_context *)&workload);
- break;
- }
-}
-
-void workload_yield(void)
-{
- /* set current workload state to ready */
- workload_state = MARS_WORKLOAD_STATE_READY;
-
- /* workload type specific handling */
- switch (workload_type) {
- case MARS_WORKLOAD_TYPE_TASK:
- /* save non-volatile registers */
- registers_save();
-
- /* yield the task context */
- task_yield((struct mars_task_context *)&workload);
- break;
- }
-}
-
-void workload_resume(void)
-{
- /* set current workload state to running */
- workload_state = MARS_WORKLOAD_STATE_RUNNING;
-
- /* workload type specific handling */
- switch (workload_type) {
- case MARS_WORKLOAD_TYPE_TASK:
- /* resume the task context */
- task_resume((struct mars_task_context *)&workload);
-
- /* restore non-volatile registers */
- registers_restore();
- break;
- }
-}
-
-int workload_schedule(uint16_t workload_id, void *args, uint8_t priority)
-{
- struct mars_workload_context schedule_workload;
- uint8_t schedule_workload_type;
- uint64_t schedule_workload_ea;
- uint64_t block_ea;
- int block;
- int index;
-
- /* check function params */
- if (workload_id >= MARS_WORKLOAD_MAX)
- return MARS_ERROR_PARAMS;
- if (workload_id == workload_index)
- return MARS_ERROR_PARAMS;
-
- /* calculate block/index from id */
- block = workload_id / MARS_WORKLOAD_PER_BLOCK;
- index = workload_id % MARS_WORKLOAD_PER_BLOCK;
-
- /* calculate block ea */
- block_ea = queue_header.queue_ea +
- offsetof(struct mars_workload_queue, block) +
- sizeof(struct mars_workload_queue_block) * block;
-
- mars_mutex_lock_get(block_ea, (struct mars_mutex *)&queue_block);
-
- /* make sure workload is in the correct state */
- if (MARS_BITS_GET(&queue_block.bits[index], STATE) !=
- MARS_WORKLOAD_STATE_FINISHED) {
- mars_mutex_unlock_put(block_ea,
- (struct mars_mutex *)&queue_block);
- return MARS_ERROR_STATE;
- }
-
- /* get information of workload to schedule */
- schedule_workload_type = MARS_BITS_GET(&queue_block.bits[index], TYPE);
- schedule_workload_ea = queue_header.context_ea +
- workload_id * sizeof(struct mars_workload_context);
-
- /* dma the workload context code into LS from main memory */
- mars_dma_get_and_wait((void *)&schedule_workload,
- schedule_workload_ea, sizeof(struct mars_workload_context),
- MARS_DMA_TAG);
-
- /* workload type specific handling */
- switch (schedule_workload_type) {
- case MARS_WORKLOAD_TYPE_TASK:
- task_schedule((struct mars_task_context *)&schedule_workload,
- (struct mars_task_args *)args);
- break;
- }
-
- /* dma the workload context code into main memory from LS */
- mars_dma_put_and_wait((void *)&schedule_workload,
- schedule_workload_ea, sizeof(struct mars_workload_context),
- MARS_DMA_TAG);
-
- /* initialize queue block bits */
- MARS_BITS_SET(&queue_block.bits[index], STATE,
- MARS_WORKLOAD_STATE_READY);
- MARS_BITS_SET(&queue_block.bits[index], PRIORITY,
- priority);
- MARS_BITS_SET(&queue_block.bits[index], COUNTER,
- MARS_WORKLOAD_COUNTER_MIN);
- MARS_BITS_SET(&queue_block.bits[index], SIGNAL,
- MARS_WORKLOAD_SIGNAL_OFF);
- MARS_BITS_SET(&queue_block.bits[index], WAIT_ID,
- MARS_WORKLOAD_ID_NONE);
-
- mars_mutex_unlock_put(block_ea, (struct mars_mutex *)&queue_block);
-
- return MARS_SUCCESS;
-}
-
-int workload_wait(uint16_t workload_id)
-{
- uint64_t block_ea;
- int block;
- int index;
-
- /* check function params */
- if (workload_id >= MARS_WORKLOAD_MAX)
- return MARS_ERROR_PARAMS;
- if (workload_id == workload_index)
- return MARS_ERROR_PARAMS;
-
- /* calculate block/index from id */
- block = workload_index / MARS_WORKLOAD_PER_BLOCK;
- index = workload_index % MARS_WORKLOAD_PER_BLOCK;
-
- /* calculate block ea */
- block_ea = queue_header.queue_ea +
- offsetof(struct mars_workload_queue, block) +
- sizeof(struct mars_workload_queue_block) * block;
-
- mars_mutex_lock_get(block_ea, (struct mars_mutex *)&queue_block);
-
- /* make sure workload is initialized */
- if (MARS_BITS_GET(&queue_block.bits[index], STATE) ==
- MARS_WORKLOAD_STATE_NONE) {
- mars_mutex_unlock_put(block_ea,
- (struct mars_mutex *)&queue_block);
- return MARS_ERROR_STATE;
- }
-
- /* set the workload id to wait for */
- MARS_BITS_SET(&queue_block.bits[index], WAIT_ID, workload_id);
-
- mars_mutex_unlock_put(block_ea, (struct mars_mutex *)&queue_block);
-
- return MARS_SUCCESS;
-}
-
-int workload_try_wait(uint16_t workload_id)
-{
- uint64_t block_ea;
- int block;
- int index;
-
- /* check function params */
- if (workload_id >= MARS_WORKLOAD_MAX)
- return MARS_ERROR_PARAMS;
- if (workload_id == workload_index)
- return MARS_ERROR_PARAMS;
-
- /* calculate block/index from id */
- block = workload_id / MARS_WORKLOAD_PER_BLOCK;
- index = workload_id % MARS_WORKLOAD_PER_BLOCK;
-
- /* calculate block ea */
- block_ea = queue_header.queue_ea +
- offsetof(struct mars_workload_queue, block) +
- sizeof(struct mars_workload_queue_block) * block;
-
- mars_mutex_lock_get(block_ea, (struct mars_mutex *)&queue_block);
-
- /* check for valid state */
- if (MARS_BITS_GET(&queue_block.bits[index], STATE) ==
- MARS_WORKLOAD_STATE_NONE) {
- mars_mutex_unlock_put(block_ea,
- (struct mars_mutex *)&queue_block);
- return MARS_ERROR_STATE;
- }
-
- mars_mutex_unlock_put(block_ea, (struct mars_mutex *)&queue_block);
-
- /* check if workload is finished */
- if (MARS_BITS_GET(&queue_block.bits[index], STATE) !=
- MARS_WORKLOAD_STATE_FINISHED)
- return MARS_ERROR_BUSY;
-
- return MARS_SUCCESS;
-}
-
-int workload_signal_send(uint16_t workload_id)
-{
- uint64_t block_ea;
- int block;
- int index;
-
- /* check function params */
- if (workload_id >= MARS_WORKLOAD_MAX)
- return MARS_ERROR_PARAMS;
- if (workload_id == workload_index)
- return MARS_ERROR_PARAMS;
-
- /* calculate block/index from id */
- block = workload_id / MARS_WORKLOAD_PER_BLOCK;
- index = workload_id % MARS_WORKLOAD_PER_BLOCK;
-
- /* calculate block ea */
- block_ea = queue_header.queue_ea +
- offsetof(struct mars_workload_queue, block) +
- sizeof(struct mars_workload_queue_block) * block;
-
- mars_mutex_lock_get(block_ea, (struct mars_mutex *)&queue_block);
-
- /* make sure workload is initialized */
- if (MARS_BITS_GET(&queue_block.bits[index], STATE) ==
- MARS_WORKLOAD_STATE_NONE) {
- mars_mutex_unlock_put(block_ea,
- (struct mars_mutex *)&queue_block);
- return MARS_ERROR_STATE;
- }
-
- /* set the workload signal */
- MARS_BITS_SET(&queue_block.bits[index], SIGNAL,
- MARS_WORKLOAD_SIGNAL_ON);
-
- mars_mutex_unlock_put(block_ea, (struct mars_mutex *)&queue_block);
-
- return MARS_SUCCESS;
-}
-
-void workload_signal_wait(void)
-{
- /* set current workload state to waiting */
- workload_state = MARS_WORKLOAD_STATE_WAITING;
-
- /* workload type specific handling */
- switch (workload_type) {
- case MARS_WORKLOAD_TYPE_TASK:
- /* save non-volatile registers */
- registers_save();
-
- /* yield the task context */
- task_yield((struct mars_task_context *)&workload);
- break;
- }
-}
-
-int workload_signal_try_wait(void)
-{
- uint64_t block_ea;
- int block;
- int index;
-
- /* check function params */
- if (workload_index >= MARS_WORKLOAD_MAX)
- return MARS_ERROR_PARAMS;
-
- /* calculate block/index from id */
- block = workload_index / MARS_WORKLOAD_PER_BLOCK;
- index = workload_index % MARS_WORKLOAD_PER_BLOCK;
-
- /* calculate block ea */
- block_ea = queue_header.queue_ea +
- offsetof(struct mars_workload_queue, block) +
- sizeof(struct mars_workload_queue_block) * block;
-
- mars_mutex_lock_get(block_ea, (struct mars_mutex *)&queue_block);
-
- /* check for valid state */
- if (MARS_BITS_GET(&queue_block.bits[index], STATE) ==
- MARS_WORKLOAD_STATE_NONE) {
- mars_mutex_unlock_put(block_ea,
- (struct mars_mutex *)&queue_block);
- return MARS_ERROR_STATE;
- }
-
- mars_mutex_unlock_put(block_ea, (struct mars_mutex *)&queue_block);
-
- /* return busy if task has not received signal */
- if (MARS_BITS_GET(&queue_block.bits[index], SIGNAL) !=
- MARS_WORKLOAD_SIGNAL_ON)
- return MARS_ERROR_BUSY;
-
- return MARS_SUCCESS;
-}
More information about the cbe-oss-dev
mailing list