rrt0.h

Go to the documentation of this file.

 
#ifndef MRBC_SRC_RRT0_H_
#define MRBC_SRC_RRT0_H_
 
/***** Feature test switches ************************************************/
/***** System headers *******************************************************/
//@cond
#include <stddef.h>
#include <stdint.h>
#include "vm_config.h"
//@endcond
 
/***** Local headers ********************************************************/
#include "vm.h"
 
#ifdef __cplusplus
extern "C" {
#endif
/***** Constant values ******************************************************/
 
//================================================
enum MrbcTaskState {
  TASKSTATE_DORMANT   = 0x00,   
  TASKSTATE_READY     = 0x02,   
  TASKSTATE_RUNNING   = 0x03,   
  TASKSTATE_WAITING   = 0x04,   
  TASKSTATE_SUSPENDED = 0x08,   
};
 
enum MrbcTaskReason {
  TASKREASON_SLEEP = 0x01,
  TASKREASON_MUTEX = 0x02,
  TASKREASON_JOIN  = 0x04,
  TASKREASON_QUEUE = 0x08,
};
 
static const int MRBC_TASK_DEFAULT_PRIORITY = 128;
static const int MRBC_TASK_DEFAULT_STATE = TASKSTATE_READY;
 
/* Sentinel stored in queue.wakeup_tick meaning "wait without a timeout".
   The scheduler never produces this tick value for a real deadline
   (mrbc_deadline_after_ms normalizes it away), so it is safe to reserve. */
#define MRBC_WAIT_FOREVER  UINT32_MAX
 
#if !defined(MRBC_TASK_NAME_LEN)
#define MRBC_TASK_NAME_LEN 15
#endif
 
 
/***** Macros ***************************************************************/
/***** Typedefs *************************************************************/
 
struct RMutex;
 
//================================================
typedef struct RTcb {
#if defined(MRBC_DEBUG)
  uint8_t obj_mark_[4];         
#endif
  struct RTcb *next;            
  uint8_t priority;             
  uint8_t priority_preemption;  
  volatile uint8_t timeslice;   
  uint8_t state;                
  uint8_t reason;               
  char name[MRBC_TASK_NAME_LEN+1]; 
 
  union {
    uint32_t wakeup_tick;       
    struct RMutex *mutex;
    struct {
      void *target;             
      uint32_t wakeup_tick;     
    } queue;                    
  };
  const struct RTcb *tcb_join;  
  mrbc_instance *task_instance; 
 
  struct VM vm;
 
} mrbc_tcb;
 
 
//================================================
typedef struct RMutex {
  volatile int lock;
  struct RTcb *tcb;
} mrbc_mutex;
 
#define MRBC_MUTEX_INITIALIZER { 0 }
 
 
/***** Global variables *****************************************************/
/***** Function prototypes **************************************************/
//@cond
void mrbc_tick(void);
mrbc_tcb *mrbc_tcb_new(int regs_size, enum MrbcTaskState task_state, int priority);
mrbc_tcb *mrbc_create_task(const void *byte_code, mrbc_tcb *tcb);
int mrbc_delete_task(mrbc_tcb *tcb);
void mrbc_set_task_name(mrbc_tcb *tcb, const char *name);
mrbc_tcb *mrbc_find_task(const char *name);
int mrbc_start_task(mrbc_tcb *tcb);
int mrbc_run(void);
void mrbc_sleep_ms(mrbc_tcb *tcb, uint32_t ms);
void mrbc_relinquish(mrbc_tcb *tcb);
void mrbc_change_priority(mrbc_tcb *tcb, int priority);
void mrbc_suspend_task(mrbc_tcb *tcb);
void mrbc_resume_task(mrbc_tcb *tcb);
void mrbc_terminate_task(mrbc_tcb *tcb);
void mrbc_join_task(mrbc_tcb *tcb, const mrbc_tcb *tcb_join);
mrbc_mutex *mrbc_mutex_init(mrbc_mutex *mutex);
int mrbc_mutex_lock(mrbc_mutex *mutex, mrbc_tcb *tcb);
int mrbc_mutex_unlock(mrbc_mutex *mutex, mrbc_tcb *tcb);
int mrbc_mutex_trylock(mrbc_mutex *mutex, mrbc_tcb *tcb);
void mrbc_cleanup(void);
void mrbc_init(void *heap_ptr, unsigned int size);
void pq(const mrbc_tcb *p_tcb);
void pqall(void);
void mrbc_task_q_insert(mrbc_tcb *p_tcb);
void mrbc_task_q_delete(mrbc_tcb *p_tcb);
mrbc_tcb *mrbc_task_q_waiting_head(void);
uint32_t mrbc_deadline_after_ms(mrbc_int_t ms, int *p_overflow);
int mrbc_deadline_reached(uint32_t deadline);
void mrbc_register_wakeup(uint32_t wakeup_tick);
//@endcond
 
#if defined(MRBC_TASK_SCHEDULER_HOOK)
//================================================
void mrbc_task_set_scheduler_hook(void (*fn)(void *ud), void *ud);
#endif
 
 
/***** Inline functions *****************************************************/
//================================================================
static inline mrbc_tcb * mrbc_get_tcb( const mrbc_vm *vm )
{
  return (mrbc_tcb *)((uint8_t *)vm - offsetof(mrbc_tcb, vm));
}
 
 
#ifdef __cplusplus
}
#endif
#endif // ifndef MRBC_SRC_RRT0_H_