287 lines
8.8 KiB
C
287 lines
8.8 KiB
C
/****************************************************************************
|
|
* include/sched.h
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership. The
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance with the
|
|
* License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifndef __INCLUDE_SCHED_H
|
|
#define __INCLUDE_SCHED_H
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <strings.h>
|
|
#include <time.h>
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
|
|
/* Task Management Definitions **********************************************/
|
|
|
|
/* POSIX-like scheduling policies */
|
|
|
|
#define SCHED_NORMAL 0 /* Alias to SCHED_OTHER */
|
|
#define SCHED_OTHER 0 /* Map to SCHED_FIFO or SCHED_RR */
|
|
#define SCHED_FIFO 1 /* FIFO priority scheduling policy */
|
|
#define SCHED_RR 2 /* Round robin scheduling policy */
|
|
#define SCHED_SPORADIC 3 /* Sporadic scheduling policy */
|
|
|
|
/* Maximum number of SCHED_SPORADIC replenishments */
|
|
|
|
#define SS_REPL_MAX CONFIG_SCHED_SPORADIC_MAXREPL
|
|
|
|
/* Cancellation definitions *************************************************/
|
|
|
|
/* Cancellation states used by task_setcancelstate() */
|
|
|
|
#define TASK_CANCEL_ENABLE (0)
|
|
#define TASK_CANCEL_DISABLE (1)
|
|
|
|
/* Cancellation types used by task_setcanceltype() */
|
|
|
|
#define TASK_CANCEL_DEFERRED (0)
|
|
#define TASK_CANCEL_ASYNCHRONOUS (1)
|
|
|
|
/* Pthread definitions ******************************************************/
|
|
|
|
#define PTHREAD_KEYS_MAX CONFIG_TLS_NELEM
|
|
|
|
/* CPU affinity mask helpers ************************************************/
|
|
|
|
/* These are not standard but are defined for Linux compatibility */
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/* void CPU_ZERO(FAR cpu_set_t *set); */
|
|
|
|
# define CPU_ZERO(s) do { *(s) = 0; } while (0)
|
|
|
|
/* void CPU_SET(int cpu, FAR cpu_set_t *set); */
|
|
|
|
# define CPU_SET(c,s) do { *(s) |= (1 << (c)); } while (0)
|
|
|
|
/* void CPU_CLR(int cpu, FAR cpu_set_t *set); */
|
|
|
|
# define CPU_CLR(c,s) do { *(s) &= ~(1 << (c)); } while (0)
|
|
|
|
/* int CPU_ISSET(int cpu, FAR const cpu_set_t *set); */
|
|
|
|
# define CPU_ISSET(c,s) ((*(s) & (1 << (c))) != 0)
|
|
|
|
/* int CPU_COUNT(FAR const cpu_set_t *set); */
|
|
|
|
# define CPU_COUNT(s) popcountl(*s)
|
|
|
|
/* void CPU_AND(FAR cpu_set_t *destset, FAR const cpu_set_t *srcset1,
|
|
* FAR const cpu_set_t *srcset2);
|
|
*/
|
|
|
|
# define CPU_AND(d,s1,s2) do { *(d) = *(s1) & *(s2); } while (0)
|
|
|
|
/* void CPU_OR(FAR cpu_set_t *destset, FAR const cpu_set_t *srcset1,
|
|
* FAR const cpu_set_t *srcset2);
|
|
*/
|
|
|
|
# define CPU_OR(d,s1,s2) do { *(d) = *(s1) | *(s2); } while (0)
|
|
|
|
/* void CPU_XOR(FAR cpu_set_t *destset, FAR const cpu_set_t *srcset1,
|
|
* FAR const cpu_set_t *srcset2);
|
|
*/
|
|
|
|
# define CPU_XOR(d,s1,s2) do { *(d) = *(s1) ^ *(s2); } while (0)
|
|
|
|
/* int CPU_EQUAL(FAR const cpu_set_t *set1, FAR const cpu_set_t *set2); */
|
|
|
|
# define CPU_EQUAL(s1,s2) (*(s2) == *(s2))
|
|
|
|
/* REVISIT: Variably sized CPU sets are not supported */
|
|
|
|
/* FAR cpu_set_t *CPU_ALLOC(int num_cpus); */
|
|
|
|
# define CPU_ALLOC(n) (FAR cpu_set_t *)malloc(sizeof(cpu_set_t));
|
|
|
|
/* void CPU_FREE(cpu_set_t *set); */
|
|
|
|
# define CPU_FREE(s) free(s)
|
|
|
|
/* size_t CPU_ALLOC_SIZE(int num_cpus); */
|
|
|
|
# define CPU_ALLOC_SIZE(n) sizeof(cpu_set_t)
|
|
|
|
/* void CPU_ZERO_S(size_t setsize, FAR cpu_set_t *set); */
|
|
|
|
# define CPU_ZERO_S(n,s) CPU_ZERO_S(s)
|
|
|
|
/* void CPU_SET_S(int cpu, size_t setsize, FAR cpu_set_t *set); */
|
|
|
|
# define CPU_SET_S(c,n,s) CPU_SET(c,s)
|
|
|
|
/* void CPU_CLR_S(int cpu, size_t setsize, FAR cpu_set_t *set); */
|
|
|
|
# define CPU_CLR_S(c,n,s) CPU_CLR(c,s)
|
|
|
|
/* int CPU_ISSET_S(int cpu, size_t setsize, FAR const cpu_set_t *set); */
|
|
|
|
# define CPU_ISSET_S(c,n,s) CPU_ISSET(c,s)
|
|
|
|
/* int CPU_COUNT_S(size_t setsize, FAR const cpu_set_t *set); */
|
|
|
|
# define CPU_COUNT_S(n,s) CPU_COUNT(s)
|
|
|
|
/* void CPU_AND_S(size_t setsize, FAR cpu_set_t *destset,
|
|
* FAR const cpu_set_t *srcset1,
|
|
* FAR const cpu_set_t *srcset2);
|
|
*/
|
|
|
|
# define CPU_AND_S(n,d,s1,s2) CPU_AND(d,s1,s2)
|
|
|
|
/* void CPU_OR_S(size_t setsize, FAR cpu_set_t *destset,
|
|
* FAR const cpu_set_t *srcset1,
|
|
* FAR const cpu_set_t *srcset2);
|
|
*/
|
|
|
|
# define CPU_OR_S(n,d,s1,s2) CPU_OR(d,s1,s2)
|
|
|
|
/* void CPU_XOR_S(size_t setsize, FAR cpu_set_t *destset,
|
|
* FAR const cpu_set_t *srcset1,
|
|
* FAR const cpu_set_t *srcset2);
|
|
*/
|
|
|
|
# define CPU_XOR_S(n,d,s1,s2) CPU_XOR(d,s1,s2)
|
|
|
|
/* int CPU_EQUAL_S(size_t setsize, FAR const cpu_set_t *set1,
|
|
* FAR const cpu_set_t *set2);
|
|
*/
|
|
|
|
# define CPU_EQUAL_S(n,s1,s2) CPU_EQUAL(s1,s2)
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
/****************************************************************************
|
|
* Public Type Definitions
|
|
****************************************************************************/
|
|
|
|
/* This is the POSIX-like scheduling parameter structure */
|
|
|
|
struct sched_param
|
|
{
|
|
int sched_priority; /* Base thread priority */
|
|
|
|
#ifdef CONFIG_SCHED_SPORADIC
|
|
int sched_ss_low_priority; /* Low scheduling priority for sporadic
|
|
* server */
|
|
struct timespec sched_ss_repl_period; /* Replenishment period for sporadic
|
|
* server. */
|
|
struct timespec sched_ss_init_budget; /* Initial budget for sporadic server */
|
|
int sched_ss_max_repl; /* Maximum pending replenishments for
|
|
* sporadic server. */
|
|
#endif
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Public Data
|
|
****************************************************************************/
|
|
|
|
#ifndef __ASSEMBLY__
|
|
#undef EXTERN
|
|
#if defined(__cplusplus)
|
|
#define EXTERN extern "C"
|
|
extern "C"
|
|
{
|
|
#else
|
|
#define EXTERN extern
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Public Function Prototypes
|
|
****************************************************************************/
|
|
|
|
/* Task Control Interfaces (non-standard) */
|
|
|
|
#ifndef CONFIG_BUILD_KERNEL
|
|
int task_create(FAR const char *name, int priority, int stack_size,
|
|
main_t entry, FAR char * const argv[]);
|
|
int task_create_with_stack(FAR const char *name, int priority,
|
|
FAR void *stack_addr, int stack_size,
|
|
main_t entry, FAR char * const argv[]);
|
|
#endif
|
|
int task_delete(pid_t pid);
|
|
int task_restart(pid_t pid);
|
|
|
|
int task_setcancelstate(int state, FAR int *oldstate);
|
|
int task_setcanceltype(int type, FAR int *oldtype);
|
|
void task_testcancel(void);
|
|
|
|
/* Task Scheduling Interfaces (based on POSIX APIs) */
|
|
|
|
int sched_setparam(pid_t pid, FAR const struct sched_param *param);
|
|
int sched_getparam(pid_t pid, FAR struct sched_param *param);
|
|
int sched_setscheduler(pid_t pid, int policy,
|
|
FAR const struct sched_param *param);
|
|
int sched_getscheduler(pid_t pid);
|
|
int sched_yield(void);
|
|
int sched_get_priority_max(int policy);
|
|
int sched_get_priority_min(int policy);
|
|
int sched_rr_get_interval(pid_t pid, FAR struct timespec *interval);
|
|
|
|
#ifdef CONFIG_SMP
|
|
/* Task affinity */
|
|
|
|
int sched_setaffinity(pid_t pid, size_t cpusetsize,
|
|
FAR const cpu_set_t *mask);
|
|
int sched_getaffinity(pid_t pid, size_t cpusetsize, FAR cpu_set_t *mask);
|
|
int sched_cpucount(FAR const cpu_set_t *set);
|
|
int sched_getcpu(void);
|
|
#else
|
|
# define sched_getcpu() 0
|
|
#endif /* CONFIG_SMP */
|
|
|
|
/* Task Switching Interfaces (non-standard) */
|
|
|
|
int sched_lock(void);
|
|
int sched_unlock(void);
|
|
int sched_lockcount(void);
|
|
|
|
/* Queries */
|
|
|
|
bool sched_idletask(void);
|
|
|
|
/* Task Backtrace */
|
|
|
|
#ifdef CONFIG_SCHED_BACKTRACE
|
|
int sched_backtrace(pid_t tid, FAR void **buffer, int size, int skip);
|
|
void sched_dumpstack(pid_t tid);
|
|
#else
|
|
# define sched_backtrace(tid, buffer, size, skip) 0
|
|
# define sched_dumpstack(tid)
|
|
#endif
|
|
|
|
#undef EXTERN
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
#endif /* __ASSEMBLY__ */
|
|
|
|
#endif /* __INCLUDE_SCHED_H */
|