sched.h

Go to the documentation of this file.

/*
 * Copyright (C) 2014-2017 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#pragma once
 
#include <stddef.h>
#include <inttypes.h>
 
#include "kernel_defines.h"
#include "native_sched.h"
#include "clist.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef MAXTHREADS
#if defined(MODULE_CORE_THREAD)
#define MAXTHREADS 32
#else
#define MAXTHREADS 0
#endif
#endif
 
#define KERNEL_PID_UNDEF 0
 
#define KERNEL_PID_FIRST (KERNEL_PID_UNDEF + 1)
 
#define KERNEL_PID_LAST (KERNEL_PID_FIRST + MAXTHREADS - 1)
 
#define PRIkernel_pid PRIi16
 
#if defined(DEVELHELP) || defined(DOXYGEN)
#ifndef SCHED_TEST_STACK
#define SCHED_TEST_STACK    1
#endif  /* SCHED_TEST_STACK */
#endif  /* DEVELHELP */
 
typedef int16_t kernel_pid_t;
 
static inline int pid_is_valid(kernel_pid_t pid)
{
    return ((KERNEL_PID_FIRST <= pid) && (pid <= KERNEL_PID_LAST));
}
typedef struct _thread thread_t;
 
typedef enum {
    STATUS_STOPPED,                 
    STATUS_ZOMBIE,                  
    STATUS_SLEEPING,                
    STATUS_MUTEX_BLOCKED,           
    STATUS_RECEIVE_BLOCKED,         
    STATUS_SEND_BLOCKED,            
    STATUS_REPLY_BLOCKED,           
    STATUS_FLAG_BLOCKED_ANY,        
    STATUS_FLAG_BLOCKED_ALL,        
    STATUS_MBOX_BLOCKED,            
    STATUS_COND_BLOCKED,            
    STATUS_RUNNING,                 
    STATUS_PENDING,                 
    STATUS_NUMOF                    
} thread_status_t;
#define STATUS_ON_RUNQUEUE      STATUS_RUNNING  
#define STATUS_NOT_FOUND ((thread_status_t)~0)  
#ifndef SCHED_PRIO_LEVELS
#define SCHED_PRIO_LEVELS 16
#endif
 
thread_t *sched_run(void);
 
void sched_set_status(thread_t *process, thread_status_t status);
 
void sched_switch(uint16_t other_prio);
 
NORETURN void cpu_switch_context_exit(void);
 
extern volatile unsigned int sched_context_switch_request;
 
extern volatile thread_t *sched_threads[KERNEL_PID_LAST + 1];
 
extern volatile int sched_num_threads;
 
extern clist_node_t sched_runqueues[SCHED_PRIO_LEVELS];
 
NORETURN void sched_task_exit(void);
 
void sched_change_priority(thread_t *thread, uint8_t priority);
 
void sched_arch_idle(void);
 
#if IS_USED(MODULE_SCHED_CB) || defined(DOXYGEN)
typedef void (*sched_callback_t)(kernel_pid_t active, kernel_pid_t next);
 
void sched_register_cb(sched_callback_t callback);
#endif /* MODULE_SCHED_CB */
 
static inline void sched_runq_advance(uint8_t prio)
{
    clist_lpoprpush(&sched_runqueues[prio]);
}
 
#if (IS_USED(MODULE_SCHED_RUNQ_CALLBACK)) || defined(DOXYGEN)
extern void sched_runq_callback(uint8_t prio);
#endif
 
static inline int sched_runq_is_empty(uint8_t prio)
{
    return clist_is_empty(&sched_runqueues[prio]);
}
 
static inline int sched_runq_exactly_one(uint8_t prio)
{
    return clist_exactly_one(&sched_runqueues[prio]);
}
 
static inline int sched_runq_more_than_one(uint8_t prio)
{
    return clist_more_than_one(&sched_runqueues[prio]);
}
 
#ifdef __cplusplus
}
#endif