[Cbe-oss-dev] [PATCH 3/5]base: add unschedule api
Yuji Mano
yuji.mano at am.sony.com
Wed Mar 25 12:48:22 EST 2009
This patch adds the workload unschedule API to the kernel syscalls and
workload module API.
The unschedule API will allow for unscheduling of scheduled workloads that might
become necessary in certain situations such as handling errors that might cause
workloads to get stuck in a state that prevents it from finishing.
Signed-off-by: Yuji Mano <yuji.mano at am.sony.com>
---
base/include/host/mars/workload_queue.h | 74 ++++++++++++++-
base/include/mpu/mars/module.h | 61 ++++++++++++
base/src/common/kernel_internal_types.h | 5 -
base/src/common/workload_internal_types.h | 27 ++---
base/src/host/lib/workload_queue.c | 56 +++++++++++
base/src/mpu/kernel/kernel.c | 145 ++++++++++++++++++++++--------
base/src/mpu/lib/module.S | 48 +++++++--
7 files changed, 349 insertions(+), 67 deletions(-)
--- a/base/include/host/mars/workload_queue.h
+++ b/base/include/host/mars/workload_queue.h
@@ -84,7 +84,7 @@ int mars_workload_queue_query(struct mar
*
* If workload_ea is not NULL, the ea of the workload will be returned.
*
- * This call will lock the workload queue until the matching call to
+ * The workload adding process is not completed until the matching call to
* \ref mars_workload_queue_add_end is made.
* The user should make any necessary updates to the returned workload context
* in between this begin call and the end call.
@@ -142,7 +142,7 @@ int mars_workload_queue_add_end(struct m
*
* If workload_ea is not NULL, the ea of the workload will be returned.
*
- * This call will lock the workload queue until the matching call to
+ * The workload removing process is not completed until the matching call to
* \ref mars_workload_queue_remove_end is made.
* The user should make any necessary updates to the returned workload context
* in between this begin call and the end call.
@@ -194,7 +194,7 @@ int mars_workload_queue_remove_end(struc
*
* If workload_ea is not NULL, the ea of the workload will be returned.
*
- * This call will lock the workload queue until the matching call to
+ * The workload scheduling process is not completed until the matching call to
* \ref mars_workload_queue_schedule_end is made.
* The user should make any necessary updates to the returned workload context
* in between this begin call and the end call.
@@ -238,6 +238,74 @@ int mars_workload_queue_schedule_end(str
/**
* \ingroup group_mars_workload_queue
+ * \brief <b>[host]</b> Begins unscheduling of specified workload.
+ *
+ * This function will begin unscheduling the workload specified.
+ * This only initiates the unscheduling of the workload.
+ * This function must be completed with a matching call to
+ * \ref mars_workload_queue_unschedule_end to guarantee the completion of the
+ * unscheduling.
+ *
+ * If workload_ea is not NULL, the ea of the workload will be returned.
+ *
+ * The workload unscheduling process is not completed until the matching call to
+ * \ref mars_workload_queue_unschedule_end is made.
+ * The user should make any necessary updates to the returned workload context
+ * in between this begin call and the end call.
+ *
+ * When a workload is unscheduled, it will be put into a finished state and any
+ * entities waiting on the workload to finish will be resumed.
+ *
+ * If a scheduled workload is unscheduled before execution, the workload will
+ * not be executed until a subsequent scheduling request is made.
+ *
+ * If the workload is currently in a waiting state, calling unschedule will
+ * finish the workload and will not be resumed from the waiting state.
+ *
+ * If the workload is currently in a running state, calling unschedule will
+ * immediately put the workload into a finished state. However, execution of the
+ * workload will only be suspended when the workload yields, waits, or finishes.
+ *
+ * \note
+ * Trying to unschedule a workload that has not yet been scheduled, or has
+ * already finished a previously scheduled execution will return an error.
+ *
+ * \param[in] mars - address of pointer to MARS context
+ * \param[in] id - id of workload
+ * \param[out] workload_ea - address of pointer to workload context ea
+ * \return
+ * MARS_SUCCESS - workload aborted
+ * \n MARS_ERROR_NULL - null pointer specified
+ * \n MARS_ERROR_PARAMS - invalid mars context or workload id specified
+ * \n MARS_ERROR_STATE - workload is not scheduled or has finished
+ */
+int mars_workload_queue_unschedule_begin(struct mars_context *mars,
+ uint16_t id,
+ uint64_t *workload_ea);
+
+/**
+ * \ingroup group_mars_workload_queue
+ * \brief <b>[host]</b> Ends unscheduling of specified workload.
+ *
+ * This function will complete an unschedule operation previously initiated with
+ * \ref mars_workload_queue_unschedule_begin.
+ * This function must be called in pair for each call to
+ * \ref mars_workload_queue_unschedule_begin to guarantee the completion of the
+ * initiated unschedule operation.
+ *
+ * \param[in] mars - address of pointer to MARS context
+ * \param[in] id - id of workload
+ * \return
+ * MARS_SUCCESS - workload unscheduling complete
+ * \n MARS_ERROR_NULL - null pointer specified
+ * \n MARS_ERROR_PARAMS - invalid mars context or workload id specified
+ * \n MARS_ERROR_STATE - workload unscheduling not started
+ */
+int mars_workload_queue_unschedule_end(struct mars_context *mars,
+ uint16_t id);
+
+/**
+ * \ingroup group_mars_workload_queue
* \brief <b>[host]</b> Waits for specified workload to finish.
*
* This function will block and wait until the specified workload finishes.
--- a/base/include/mpu/mars/module.h
+++ b/base/include/mpu/mars/module.h
@@ -193,7 +193,7 @@ int mars_module_workload_signal_reset(vo
* \ref mars_module_workload_schedule_end to guarantee the completion of the
* scheduling.
*
- * This call will lock the workload queue until the matching call to
+ * The workload scheduling process is not complete until the matching call to
* \ref mars_module_workload_schedule_end is made.
* The user should make any necessary updates to the returned workload context
* in between this begin call and the end call.
@@ -230,6 +230,65 @@ int mars_module_workload_schedule_end(ui
/**
* \ingroup group_mars_workload_module
+ * \brief <b>[MPU]</b> Begins unscheduling of specified workload.
+ *
+ * This function will begin unscheduling the workload specified.
+ * This only initiates the unscheduling of the workload.
+ * This function must be completed with a matching call to
+ * \ref mars_module_workload_unschedule_end to guarantee the completion of the
+ * unscheduling.
+ *
+ * The workload unscheduling process is not complete until the matching call to
+ * \ref mars_module_workload_unschedule_end is made.
+ * The user should make any necessary updates to the returned workload context
+ * in between this begin call and the end call.
+ *
+ * When a workload is unscheduled, it will be put into a finished state and any
+ * entities waiting on the workload to finish will be resumed.
+ *
+ * If a scheduled workload is unscheduled before execution, the workload will
+ * not be executed until a subsequent scheduling request is made.
+ *
+ * If the workload is currently in a waiting state, calling unschedule will
+ * finish the workload and will not be resumed from the waiting state.
+ *
+ * If the workload is currently in a running state, calling unschedule will
+ * immediately put the workload into a finished state. However, execution of the
+ * workload will only be suspended when the workload yields, waits, or finishes.
+ *
+ * \note
+ * Trying to unschedule a workload that has not yet been scheduled, or has
+ * already finished a previously scheduled execution will return an error.
+ *
+ * \param[in] id - id of workload
+ * \param[out] workload - address of pointer to workload context
+ * \return
+ * MARS_SUCCESS - workload unscheduling started
+ * \n MARS_ERROR_PARAMS - invalid workload id specified
+ * \n MARS_ERROR_STATE - workload is not scheduled or has finished
+ */
+int mars_module_workload_unschedule_begin(uint16_t id,
+ struct mars_workload_context **workload);
+
+/**
+ * \ingroup group_mars_workload_module
+ * \brief <b>[MPU]</b> Ends unscheduling of specified workload.
+ *
+ * This function will complete an unschedule operation previously initiated with
+ * \ref mars_module_workload_unschedule_begin.
+ * This function must be called in pair for each call to
+ * \ref mars_module_workload_unschedule_begin to guarantee the completion of the
+ * initiated unschedule operation.
+ *
+ * \return
+ * MARS_SUCCESS - workload unscheduling complete
+ * \n MARS_ERROR_PARAMS - invalid workload id specified
+ * \n MARS_ERROR_STATE - workload unscheduling not started
+ */
+int mars_module_workload_unschedule_end(uint16_t id);
+
+/**
+ * \ingroup group_mars_workload_module
* \brief <b>[MPU]</b> Returns execution to kernel with workload in wait state.
*
* This function will yield execution of the calling workload module and return
--- a/base/src/common/kernel_internal_types.h
+++ b/base/src/common/kernel_internal_types.h
@@ -76,8 +76,11 @@ struct mars_kernel_syscalls {
int (*workload_signal_set)(uint16_t id);
int (*workload_signal_reset)(void);
int (*workload_schedule_begin)(uint16_t id, uint8_t priority,
- struct mars_workload_context **workload);
+ struct mars_workload_context **workload);
int (*workload_schedule_end)(uint16_t id, int cancel);
+ int (*workload_unschedule_begin)(uint16_t id,
+ struct mars_workload_context **workload);
+ int (*workload_unschedule_end)(uint16_t id);
int (*host_signal_send)(uint64_t watch_point_ea);
int (*host_callback_set)(uint64_t callback_ea,
--- a/base/src/common/workload_internal_types.h
+++ b/base/src/common/workload_internal_types.h
@@ -47,16 +47,17 @@
#define MARS_WORKLOAD_STATE_ADDING 0x01 /* adding now */
#define MARS_WORKLOAD_STATE_REMOVING 0x02 /* removing now */
#define MARS_WORKLOAD_STATE_SCHEDULING 0x04 /* scheduling now */
-#define MARS_WORKLOAD_STATE_READY 0x08 /* ready to schedule */
-#define MARS_WORKLOAD_STATE_WAITING 0x10 /* waiting for sync */
-#define MARS_WORKLOAD_STATE_RUNNING 0x20 /* currently running */
-#define MARS_WORKLOAD_STATE_FINISHED 0x40 /* not allow schedule */
+#define MARS_WORKLOAD_STATE_UNSCHEDULING 0x08 /* unscheduling now */
+#define MARS_WORKLOAD_STATE_READY 0x10 /* ready to schedule */
+#define MARS_WORKLOAD_STATE_WAITING 0x20 /* waiting for sync */
+#define MARS_WORKLOAD_STATE_RUNNING 0x40 /* currently running */
+#define MARS_WORKLOAD_STATE_FINISHED 0x80 /* not allow schedule */
#define MARS_WORKLOAD_PRIORITY_MIN 0x00 /* minimum priority */
#define MARS_WORKLOAD_PRIORITY_MAX 0xff /* maximum priority */
#define MARS_WORKLOAD_COUNTER_MIN 0x0000 /* minimum counter */
-#define MARS_WORKLOAD_COUNTER_MAX 0xffff /* maximum counter */
+#define MARS_WORKLOAD_COUNTER_MAX 0x7fff /* maximum counter */
#define MARS_WORKLOAD_SIGNAL_OFF 0x0 /* signal set off */
#define MARS_WORKLOAD_SIGNAL_ON 0x1 /* signal set on */
@@ -112,23 +113,23 @@
/*
* MARS workload queue block workload bits (64-bits)
* ------------------------------------------------------------------
- * |[63...57]|[56....49]|[48....33]|[ 32 ]|[31.....16]|[15......0]|
+ * |[63....56]|[55....48]|[47....33]|[ 32 ]|[31.....16]|[15......0]|
* ------------------------------------------------------------------
- * | 7-bits | 8-bits | 16-bits | 1-bit | 16-bits | 16-bits |
+ * | 8-bits | 8-bits | 15-bits | 1-bit | 16-bits | 16-bits |
* ------------------------------------------------------------------
- * | STATE | PRIORITY | COUNTER | SIGNAL | WAIT_ID | KERNEL_ID |
+ * | STATE | PRIORITY | COUNTER | SIGNAL | WAIT_ID | KERNEL_ID |
* ------------------------------------------------------------------
*/
-#define MARS_BITS_SHIFT_WORKLOAD_STATE 57
-#define MARS_BITS_SHIFT_WORKLOAD_PRIORITY 49
+#define MARS_BITS_SHIFT_WORKLOAD_STATE 56
+#define MARS_BITS_SHIFT_WORKLOAD_PRIORITY 48
#define MARS_BITS_SHIFT_WORKLOAD_COUNTER 33
#define MARS_BITS_SHIFT_WORKLOAD_SIGNAL 32
#define MARS_BITS_SHIFT_WORKLOAD_WAIT_ID 16
#define MARS_BITS_SHIFT_WORKLOAD_KERNEL_ID 0
-#define MARS_BITS_MASK_WORKLOAD_STATE 0xfe00000000000000ULL
-#define MARS_BITS_MASK_WORKLOAD_PRIORITY 0x01fe000000000000ULL
-#define MARS_BITS_MASK_WORKLOAD_COUNTER 0x0001fffe00000000ULL
+#define MARS_BITS_MASK_WORKLOAD_STATE 0xff00000000000000ULL
+#define MARS_BITS_MASK_WORKLOAD_PRIORITY 0x00ff000000000000ULL
+#define MARS_BITS_MASK_WORKLOAD_COUNTER 0x0000fffe00000000ULL
#define MARS_BITS_MASK_WORKLOAD_SIGNAL 0x0000000100000000ULL
#define MARS_BITS_MASK_WORKLOAD_WAIT_ID 0x00000000ffff0000ULL
#define MARS_BITS_MASK_WORKLOAD_KERNEL_ID 0x000000000000ffffULL
--- a/base/src/host/lib/workload_queue.c
+++ b/base/src/host/lib/workload_queue.c
@@ -761,6 +761,62 @@ int mars_workload_queue_schedule_end(str
cancel ? NULL : update_header_bits);
}
+static int unscheduling_state_bits(uint64_t bits, uint64_t param)
+{
+ (void)param;
+
+ /* check for valid state */
+ switch (MARS_BITS_GET(&bits, WORKLOAD_STATE)) {
+ case MARS_WORKLOAD_STATE_READY:
+ case MARS_WORKLOAD_STATE_RUNNING:
+ case MARS_WORKLOAD_STATE_WAITING:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+int mars_workload_queue_unschedule_begin(struct mars_context *mars,
+ uint16_t id,
+ uint64_t *workload_ea)
+{
+ return change_bits(mars, id, workload_ea,
+ unscheduling_state_bits, 0,
+ set_state_bits, MARS_WORKLOAD_STATE_UNSCHEDULING,
+ NULL);
+}
+
+int mars_workload_queue_unschedule_end(struct mars_context *mars,
+ uint16_t id)
+{
+ int ret;
+ int block;
+ int index;
+ uint64_t queue_ea;
+ uint64_t block_ea;
+ uint64_t bits_ea;
+
+ ret = change_state(mars, id, NULL,
+ MARS_WORKLOAD_STATE_UNSCHEDULING,
+ MARS_WORKLOAD_STATE_FINISHED,
+ update_header_bits);
+ if (ret != MARS_SUCCESS)
+ return ret;
+
+ queue_ea = mars->workload_queue_ea;
+
+ block = id / MARS_WORKLOAD_PER_BLOCK;
+ index = id % MARS_WORKLOAD_PER_BLOCK;
+
+ block_ea = get_block_ea(queue_ea, block);
+ bits_ea = get_block_bits_ea(block_ea, index);
+
+ /* signal any threads possibly waiting for workload to finish */
+ mars_ea_cond_signal(bits_ea, 1);
+
+ return MARS_SUCCESS;
+}
+
static int is_workload_finished(uint32_t upper, void *param)
{
(void)param;
--- a/base/src/mpu/kernel/kernel.c
+++ b/base/src/mpu/kernel/kernel.c
@@ -58,15 +58,13 @@ static struct mars_workload_queue_header
static struct mars_workload_queue_block queue_block;
/* workload */
+static struct mars_workload_context workload_buf;
static struct mars_workload_context workload;
static uint16_t workload_id;
static uint64_t workload_ea;
static uint8_t workload_state;
static uint8_t workload_is_cached;
-/* workload to schedule */
-static struct mars_workload_context schedule_workload;
-
/* workload module */
static struct mars_workload_module cached_workload_module;
static struct mars_workload_module *workload_module;
@@ -414,6 +412,28 @@ static int workload_signal_reset(void)
NULL);
}
+static void begin_callback(uint16_t id)
+{
+ /* get the workload context from workload queue */
+ dma_get(&workload_buf, get_workload_ea(id),
+ MARS_WORKLOAD_CONTEXT_SIZE, MARS_KERNEL_DMA_TAG);
+ dma_wait(MARS_KERNEL_DMA_TAG);
+
+ /* update queue header bits */
+ update_header_bits(id / MARS_WORKLOAD_PER_BLOCK);
+}
+
+static void end_callback(uint16_t id)
+{
+ /* put the workload context into workload queue */
+ dma_put((void *)&workload_buf, get_workload_ea(id),
+ MARS_WORKLOAD_CONTEXT_SIZE, MARS_KERNEL_DMA_TAG);
+ dma_wait(MARS_KERNEL_DMA_TAG);
+
+ /* update queue header bits */
+ update_header_bits(id / MARS_WORKLOAD_PER_BLOCK);
+}
+
static uint64_t set_schedule_bits(uint64_t bits, uint64_t priority)
{
/* set the info bits inside queue block for this workload */
@@ -426,14 +446,6 @@ static uint64_t set_schedule_bits(uint64
return bits;
}
-static void schedule_begin_callback(uint16_t id)
-{
- /* get the workload context from workload queue */
- dma_get(&schedule_workload, get_workload_ea(id),
- MARS_WORKLOAD_CONTEXT_SIZE, MARS_KERNEL_DMA_TAG);
- dma_wait(MARS_KERNEL_DMA_TAG);
-}
-
static int workload_schedule_begin(uint16_t id, uint8_t priority,
struct mars_workload_context **workload)
{
@@ -443,35 +455,84 @@ static int workload_schedule_begin(uint1
ret = change_bits(id,
check_state_bits, MARS_WORKLOAD_STATE_FINISHED,
set_schedule_bits, priority,
- schedule_begin_callback);
+ begin_callback);
if (ret != MARS_SUCCESS)
return ret;
/* if requested set workload context pointer to return */
if (workload)
- *workload = &schedule_workload;
+ *workload = &workload_buf;
return MARS_SUCCESS;
}
-static void schedule_end_callback(uint16_t id)
-{
- /* put the workload context into workload queue */
- dma_put((void *)&schedule_workload, get_workload_ea(id),
- MARS_WORKLOAD_CONTEXT_SIZE, MARS_KERNEL_DMA_TAG);
- dma_wait(MARS_KERNEL_DMA_TAG);
-
- /* update queue header bits */
- update_header_bits(id / MARS_WORKLOAD_PER_BLOCK);
-}
-
static int workload_schedule_end(uint16_t id, int cancel)
{
return change_state(id,
MARS_WORKLOAD_STATE_SCHEDULING,
cancel ? MARS_WORKLOAD_STATE_FINISHED :
MARS_WORKLOAD_STATE_READY,
- cancel ? NULL : schedule_end_callback);
+ end_callback);
+}
+
+static int unscheduling_state_bits(uint64_t bits, uint64_t param)
+{
+ (void)param;
+
+ uint8_t state = MARS_BITS_GET(&bits, WORKLOAD_STATE);
+
+ return (state & (MARS_WORKLOAD_STATE_READY |
+ MARS_WORKLOAD_STATE_RUNNING |
+ MARS_WORKLOAD_STATE_WAITING));
+}
+
+static int workload_unschedule_begin(uint16_t id,
+ struct mars_workload_context **workload)
+{
+ int ret;
+
+ /* change bits necessary to begin unscheduling */
+ ret = change_bits(id,
+ unscheduling_state_bits, 0,
+ set_state_bits, MARS_WORKLOAD_STATE_UNSCHEDULING,
+ begin_callback);
+ if (ret != MARS_SUCCESS)
+ return ret;
+
+ /* if requested set workload context pointer to return */
+ if (workload)
+ *workload = &workload_buf;
+
+ return MARS_SUCCESS;
+}
+
+static void notify_host_bits(uint64_t block_ea, int index);
+
+static int workload_unschedule_end(uint16_t id)
+{
+ int ret;
+ int block;
+ int index;
+ uint64_t block_ea;
+
+ ret = change_state(id,
+ MARS_WORKLOAD_STATE_UNSCHEDULING,
+ MARS_WORKLOAD_STATE_FINISHED,
+ end_callback);
+ if (ret != MARS_SUCCESS)
+ return ret;
+
+ /* calculate block/index from id */
+ block = id / MARS_WORKLOAD_PER_BLOCK;
+ index = id % MARS_WORKLOAD_PER_BLOCK;
+
+ /* calculate block ea */
+ block_ea = get_block_ea(block);
+
+ /* notify host */
+ notify_host_bits(block_ea, index);
+
+ return MARS_SUCCESS;
}
static int host_signal_send(uint64_t watch_point_ea)
@@ -578,6 +639,8 @@ static struct mars_kernel_syscalls kerne
workload_signal_reset,
workload_schedule_begin,
workload_schedule_end,
+ workload_unschedule_begin,
+ workload_unschedule_end,
host_signal_send,
host_callback_set,
host_callback_reset,
@@ -807,29 +870,41 @@ static int workload_reserve(void)
static void workload_release(void)
{
+ int unscheduled;
int block = workload_id / MARS_WORKLOAD_PER_BLOCK;
int index = workload_id % MARS_WORKLOAD_PER_BLOCK;
uint64_t block_ea = get_block_ea(block);
-
- /* put the workload context into workload queue */
- dma_put(&workload, workload_ea,
- MARS_WORKLOAD_CONTEXT_SIZE, MARS_KERNEL_DMA_TAG);
- dma_wait(MARS_KERNEL_DMA_TAG);
+ uint8_t state;
/* lock the queue block */
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], WORKLOAD_STATE, workload_state);
+ /* get current state */
+ state = MARS_BITS_GET(&queue_block.bits[index], WORKLOAD_STATE);
- /* update queue header bits */
- update_header_bits(block);
+ /* if state is unscheduling or finished, it (was/will be) aborted */
+ unscheduled = state & (MARS_WORKLOAD_STATE_UNSCHEDULING |
+ MARS_WORKLOAD_STATE_FINISHED);
+
+ if (!unscheduled) {
+ /* put the workload context into workload queue */
+ dma_put(&workload, workload_ea,
+ MARS_WORKLOAD_CONTEXT_SIZE, MARS_KERNEL_DMA_TAG);
+ dma_wait(MARS_KERNEL_DMA_TAG);
+
+ /* update current workload state in workload queue block */
+ MARS_BITS_SET(&queue_block.bits[index], WORKLOAD_STATE,
+ workload_state);
+
+ /* update queue header bits */
+ update_header_bits(block);
+ }
/* unlock the queue block */
mutex_unlock_put(block_ea, (struct mars_mutex *)&queue_block);
/* workload state is finished so notify host */
- if (workload_state & MARS_WORKLOAD_STATE_FINISHED)
+ if (!unscheduled && (workload_state & MARS_WORKLOAD_STATE_FINISHED))
notify_host_bits(block_ea, index);
}
--- a/base/src/mpu/lib/module.S
+++ b/base/src/mpu/lib/module.S
@@ -51,19 +51,21 @@
#define workload_signal_reset 44
#define workload_schedule_begin 48
#define workload_schedule_end 52
-#define host_signal_send 56
-#define host_callback_set 60
-#define host_callback_reset 64
-#define mutex_lock_get 68
-#define mutex_unlock_put 72
-#define dma_get 76
-#define dma_put 80
-#define dma_wait 84
+#define workload_unschedule_begin 56
+#define workload_unschedule_end 60
+#define host_signal_send 64
+#define host_callback_set 68
+#define host_callback_reset 72
+#define mutex_lock_get 76
+#define mutex_unlock_put 80
+#define dma_get 84
+#define dma_put 88
+#define dma_wait 92
/* NOTE: Value of defines must equal defines in workload_internal_types.h */
-#define WORKLOAD_EXIT_STATE_READY 0x08 /* MARS_WORKLOAD_STATE_READY */
-#define WORKLOAD_EXIT_STATE_WAITING 0x10 /* MARS_WORKLOAD_STATE_WAITING */
-#define WORKLOAD_EXIT_STATE_FINISHED 0x40 /* MARS_WORKLOAD_STATE_FINISHED */
+#define WORKLOAD_EXIT_STATE_READY 0x10 /* MARS_WORKLOAD_STATE_READY */
+#define WORKLOAD_EXIT_STATE_WAITING 0x20 /* MARS_WORKLOAD_STATE_WAITING */
+#define WORKLOAD_EXIT_STATE_FINISHED 0x80 /* MARS_WORKLOAD_STATE_FINISHED */
.section .bss
@@ -193,9 +195,8 @@ mars_module_workload_signal_reset:
.size mars_module_workload_signal_reset, .-mars_module_workload_signal_reset
-/* int mars_module_workload_schedule_begin(uint16_t id,
- uint8_t priority,
- struct mars_workload_context **workload) */
+/* int mars_module_workload_schedule_begin(uint16_t id, uint8_t priority,
+ struct mars_workload_context **workload) */
.global mars_module_workload_schedule_begin
.type mars_module_workload_schedule_begin, @function
mars_module_workload_schedule_begin:
@@ -213,6 +214,25 @@ mars_module_workload_schedule_end:
.size mars_module_workload_schedule_end, .-mars_module_workload_schedule_end
+/* int mars_module_workload_unschedule_begin(uint16_t id,
+ struct mars_workload_context **workload) */
+.global mars_module_workload_unschedule_begin
+.type mars_module_workload_unschedule_begin, @function
+mars_module_workload_unschedule_begin:
+ il $2, workload_unschedule_begin
+ br call_kernel_syscall
+.size mars_module_workload_unschedule_begin, .-mars_module_workload_unschedule_begin
+
+
+/* int mars_module_workload_unschedule_end(uint16_t id) */
+.global mars_module_workload_unschedule_end
+.type mars_module_workload_unschedule_end, @function
+mars_module_workload_unschedule_end:
+ il $2, workload_unschedule_end
+ br call_kernel_syscall
+.size mars_module_workload_unschedule_end, .-mars_module_workload_unschedule_end
+
+
/* void mars_module_workload_wait(void) */
.global mars_module_workload_wait
.type mars_module_workload_wait, @function
More information about the cbe-oss-dev
mailing list