kernel/unified/include/ksched.h - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2016 Wind River Systems, Inc.
  *
  * Licensed 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 _ksched__h_
 #define _ksched__h_

 #include <kernel_structs.h>

 extern k_tid_t const _main_thread;
 extern k_tid_t const _idle_thread;

 extern void _add_thread_to_ready_q(struct k_thread *thread);
 extern void _remove_thread_from_ready_q(struct k_thread *thread);
 extern void _reschedule_threads(int key);
 extern void k_sched_unlock(void);
 extern void _pend_thread(struct k_thread *thread,
 			 _wait_q_t *wait_q, int32_t timeout);
 extern void _pend_current_thread(_wait_q_t *wait_q, int32_t timeout);
 extern void _move_thread_to_end_of_prio_q(struct k_thread *thread);
 extern struct k_thread *_get_next_ready_thread(void);
 extern int __must_switch_threads(void);
 extern int32_t _ms_to_ticks(int32_t ms);
 extern void idle(void *, void *, void *);

 static inline int _is_idle_thread(void *entry_point)
 {
 	return entry_point == idle;
 }

 #define _ASSERT_VALID_PRIO(prio, entry_point) do { \
 	__ASSERT(((prio) == K_IDLE_PRIO && _is_idle_thread(entry_point)) || \
 		 (_is_prio_higher_or_equal((prio), \
 			K_LOWEST_APPLICATION_THREAD_PRIO) && \
 		  _is_prio_lower_or_equal((prio), \
 			K_HIGHEST_APPLICATION_THREAD_PRIO)), \
 		 "invalid priority (%d); allowed range: %d to %d", \
 		 (prio), \
 		 K_LOWEST_APPLICATION_THREAD_PRIO, \
 		 K_HIGHEST_APPLICATION_THREAD_PRIO); \
 	} while ((0))

 /*
  * The _is_prio_higher family: I created this because higher priorities are
  * lower numerically and I always found somewhat confusing seeing, e.g.:
  *
  *   if (t1.prio < t2.prio) /# is t1's priority higher then t2's priority ? #/
  *
  * in code. And the fact that most of the time that kind of code has this
  * exact comment warrants a function where it is embedded in the name.
  *
  * IMHO, feel free to remove them and do the comparison directly if this feels
  * like overkill.
  */

 static inline int _is_prio1_higher_than_or_equal_to_prio2(int prio1, int prio2)
 {
 	return prio1 <= prio2;
 }

 static inline int _is_prio_higher_or_equal(int prio1, int prio2)
 {
 	return _is_prio1_higher_than_or_equal_to_prio2(prio1, prio2);
 }

 static inline int _is_prio1_higher_than_prio2(int prio1, int prio2)
 {
 	return prio1 < prio2;
 }

 static inline int _is_prio_higher(int prio, int test_prio)
 {
 	return _is_prio1_higher_than_prio2(prio, test_prio);
 }

 static inline int _is_prio1_lower_than_or_equal_to_prio2(int prio1, int prio2)
 {
 	return prio1 >= prio2;
 }

 static inline int _is_prio_lower_or_equal(int prio1, int prio2)
 {
 	return _is_prio1_lower_than_or_equal_to_prio2(prio1, prio2);
 }

 static inline int _is_prio1_lower_than_prio2(int prio1, int prio2)
 {
 	return prio1 > prio2;
 }

 static inline int _is_prio_lower(int prio1, int prio2)
 {
 	return _is_prio1_lower_than_prio2(prio1, prio2);
 }

 static inline int _is_t1_higher_prio_than_t2(struct k_thread *t1,
 					     struct k_thread *t2)
 {
 	return _is_prio1_higher_than_prio2(t1->base.prio, t2->base.prio);
 }

 static inline int _is_higher_prio_than_current(struct k_thread *thread)
 {
 	return _is_t1_higher_prio_than_t2(thread, _current);
 }

 /* is thread currenlty cooperative ? */
 static inline int _is_coop(struct k_thread *thread)
 {
 	return thread->base.prio < 0;
 }

 /* is thread currently preemptible ? */
 static inline int _is_preempt(struct k_thread *thread)
 {
 	return !_is_coop(thread) && !atomic_get(&thread->base.sched_locked);
 }

 /* is current thread preemptible and we are not running in ISR context */
 static inline int _is_current_execution_context_preemptible(void)
 {
 	return !_is_in_isr() && _is_preempt(_current);
 }

 /* find out if priority is under priority inheritance ceiling */
 static inline int _is_under_prio_ceiling(int prio)
 {
 	return prio >= CONFIG_PRIORITY_CEILING;
 }

 /*
  * Find out what priority to set a thread to taking the prio ceiling into
  * consideration.
  */
 static inline int _get_new_prio_with_ceiling(int prio)
 {
 	return _is_under_prio_ceiling(prio) ? prio : CONFIG_PRIORITY_CEILING;
 }

 /* find out the prio bitmap index for a given prio */
 static inline int _get_ready_q_prio_bmap_index(int prio)
 {
 	return (prio + CONFIG_NUM_COOP_PRIORITIES) >> 5;
 }

 /* find out the prio bit for a given prio */
 static inline int _get_ready_q_prio_bit(int prio)
 {
 	return (1 << ((prio + CONFIG_NUM_COOP_PRIORITIES) & 0x1f));
 }

 /* find out the ready queue array index for a given prio */
 static inline int _get_ready_q_q_index(int prio)
 {
 	return prio + CONFIG_NUM_COOP_PRIORITIES;
 }

 #if (K_NUM_PRIORITIES > 32)
 	#error not supported yet
 #endif

 /* find out the currently highest priority where a thread is ready to run */
 /* interrupts must be locked */
 static inline int _get_highest_ready_prio(void)
 {
 	uint32_t ready = _ready_q.prio_bmap[0];

 	return find_lsb_set(ready) - 1 - CONFIG_NUM_COOP_PRIORITIES;
 }

 /*
  * Checks if current thread must be context-switched out. The caller must
  * already know that the execution context is a thread.
  */
 static inline int _must_switch_threads(void)
 {
 	return _is_preempt(_current) && __must_switch_threads();
 }

 /*
  * Internal equivalent to k_sched_lock so that it does not incur a function
  * call penalty in the kernel guts.
  *
  * Must be kept in sync until the header files are cleaned-up and the
  * applications have access to the kernel internal deta structures (through
  * APIs of course).
  */
 static inline void _sched_lock(void)
 {
 	__ASSERT(!_is_in_isr(), "");

 	atomic_inc(&_current->base.sched_locked);

 	K_DEBUG("scheduler locked (%p:%d)\n",
 		_current, _current->sched_locked);
 }

 /**
  * @brief Unlock the scheduler but do NOT reschedule
  *
  * It is incumbent upon the caller to ensure that the reschedule occurs
  * sometime after the scheduler is unlocked.
  */
 static inline void _sched_unlock_no_reschedule(void)
 {
 	__ASSERT(!_is_in_isr(), "");

 	atomic_dec(&_current->base.sched_locked);
 }

 static inline void _set_thread_states(struct k_thread *thread, uint32_t states)
 {
 	thread->base.flags |= states;
 }

 static inline void _reset_thread_states(struct k_thread *thread,
 					uint32_t states)
 {
 	thread->base.flags &= ~states;
 }

 /* mark a thread as being suspended */
 static inline void _mark_thread_as_suspended(struct k_thread *thread)
 {
 	thread->base.flags |= K_SUSPENDED;
 }

 /* mark a thread as not being suspended */
 static inline void _mark_thread_as_not_suspended(struct k_thread *thread)
 {
 	thread->base.flags &= ~K_SUSPENDED;
 }

 /* mark a thread as being in the timer queue */
 static inline void _mark_thread_as_timing(struct k_thread *thread)
 {
 	thread->base.flags |= K_TIMING;
 }

 /* mark a thread as not being in the timer queue */
 static inline void _mark_thread_as_not_timing(struct k_thread *thread)
 {
 	thread->base.flags &= ~K_TIMING;
 }

 /* check if a thread is on the timer queue */
 static inline int _is_thread_timing(struct k_thread *thread)
 {
 	return !!(thread->base.flags & K_TIMING);
 }

 static inline int _has_thread_started(struct k_thread *thread)
 {
 	return !(thread->base.flags & K_PRESTART);
 }

 /* check if a thread is ready */
 static inline int _is_thread_ready(struct k_thread *thread)
 {
 	return (thread->base.flags & K_EXECUTION_MASK) == K_READY;
 }

 /* mark a thread as pending in its TCS */
 static inline void _mark_thread_as_pending(struct k_thread *thread)
 {
 	thread->base.flags |= K_PENDING;
 }

 /* mark a thread as not pending in its TCS */
 static inline void _mark_thread_as_not_pending(struct k_thread *thread)
 {
 	thread->base.flags &= ~K_PENDING;
 }

 /* check if a thread is pending */
 static inline int _is_thread_pending(struct k_thread *thread)
 {
 	return !!(thread->base.flags & K_PENDING);
 }

 /*
  * Mark the thread as not being in the timer queue. If this makes it ready,
  * then add it to the ready queue according to its priority.
  */
 /* must be called with interrupts locked */
 static inline void _ready_thread(struct k_thread *thread)
 {
 	__ASSERT(_is_prio_higher(thread->base.prio, K_LOWEST_THREAD_PRIO) ||
 		 ((thread->base.prio == K_LOWEST_THREAD_PRIO) &&
 		  (thread == _idle_thread)),
 		 "thread %p prio too low (is %d, cannot be lower than %d)",
 		 thread, thread->base.prio,
 		 thread == _idle_thread ? K_LOWEST_THREAD_PRIO :
 					  K_LOWEST_APPLICATION_THREAD_PRIO);

 	__ASSERT(!_is_prio_higher(thread->base.prio, K_HIGHEST_THREAD_PRIO),
 		 "thread %p prio too high (id %d, cannot be higher than %d)",
 		 thread, thread->base.prio, K_HIGHEST_THREAD_PRIO);

 	/* K_PRESTART is needed to handle the start-with-delay case */
 	_reset_thread_states(thread, K_TIMING|K_PRESTART);

 	if (_is_thread_ready(thread)) {
 		_add_thread_to_ready_q(thread);
 	}
 }

 /**
  * @brief Mark a thread as started
  *
  * This routine must be called with interrupts locked.
  */
 static inline void _mark_thread_as_started(struct k_thread *thread)
 {
 	thread->base.flags &= ~K_PRESTART;
 }

 /**
  * @brief Mark thread as dead
  *
  * This routine must be called with interrupts locked.
  */
 static inline void _mark_thread_as_dead(struct k_thread *thread)
 {
 	thread->base.flags |= K_DEAD;
 }

 /*
  * Set a thread's priority. If the thread is ready, place it in the correct
  * queue.
  */
 /* must be called with interrupts locked */
 static inline void _thread_priority_set(struct k_thread *thread, int prio)
 {
 	if (_is_thread_ready(thread)) {
 		_remove_thread_from_ready_q(thread);
 		thread->base.prio = prio;
 		_add_thread_to_ready_q(thread);
 	} else {
 		thread->base.prio = prio;
 	}
 }

 /* check if thread is a thread pending on a particular wait queue */
 static inline struct k_thread *_peek_first_pending_thread(_wait_q_t *wait_q)
 {
 	return (struct k_thread *)sys_dlist_peek_head(wait_q);
 }

 /* unpend the first thread from a wait queue */
 static inline struct k_thread *_unpend_first_thread(_wait_q_t *wait_q)
 {
 	struct k_thread *thread = (struct k_thread *)sys_dlist_get(wait_q);

 	if (thread) {
 		_mark_thread_as_not_pending(thread);
 	}

 	return thread;
 }

 /* Unpend a thread from the wait queue it is on. Thread must be pending. */
 /* must be called with interrupts locked */
 static inline void _unpend_thread(struct k_thread *thread)
 {
 	__ASSERT(thread->base.flags & K_PENDING, "");

 	sys_dlist_remove(&thread->base.k_q_node);
 	_mark_thread_as_not_pending(thread);
 }

 #endif /* _ksched__h_ */
	/*
	* Copyright (c) 2016 Wind River Systems, Inc.
	*
	* Licensed 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 _ksched__h_
	#define _ksched__h_

	#include <kernel_structs.h>

	extern k_tid_t const _main_thread;
	extern k_tid_t const _idle_thread;

	extern void _add_thread_to_ready_q(struct k_thread *thread);
	extern void _remove_thread_from_ready_q(struct k_thread *thread);
	extern void _reschedule_threads(int key);
	extern void k_sched_unlock(void);
	extern void _pend_thread(struct k_thread *thread,
	_wait_q_t *wait_q, int32_t timeout);
	extern void _pend_current_thread(_wait_q_t *wait_q, int32_t timeout);
	extern void _move_thread_to_end_of_prio_q(struct k_thread *thread);
	extern struct k_thread *_get_next_ready_thread(void);
	extern int __must_switch_threads(void);
	extern int32_t _ms_to_ticks(int32_t ms);
	extern void idle(void , void , void *);

	static inline int _is_idle_thread(void *entry_point)
	{
	return entry_point == idle;
	}

	#define _ASSERT_VALID_PRIO(prio, entry_point) do { \
	__ASSERT(((prio) == K_IDLE_PRIO && _is_idle_thread(entry_point)) \|\| \
	(_is_prio_higher_or_equal((prio), \
	K_LOWEST_APPLICATION_THREAD_PRIO) && \
	_is_prio_lower_or_equal((prio), \
	K_HIGHEST_APPLICATION_THREAD_PRIO)), \
	"invalid priority (%d); allowed range: %d to %d", \
	(prio), \
	K_LOWEST_APPLICATION_THREAD_PRIO, \
	K_HIGHEST_APPLICATION_THREAD_PRIO); \
	} while ((0))

	/*
	* The _is_prio_higher family: I created this because higher priorities are
	* lower numerically and I always found somewhat confusing seeing, e.g.:
	*
	* if (t1.prio < t2.prio) /# is t1's priority higher then t2's priority ? #/
	*
	* in code. And the fact that most of the time that kind of code has this
	* exact comment warrants a function where it is embedded in the name.
	*
	* IMHO, feel free to remove them and do the comparison directly if this feels
	* like overkill.
	*/

	static inline int _is_prio1_higher_than_or_equal_to_prio2(int prio1, int prio2)
	{
	return prio1 <= prio2;
	}

	static inline int _is_prio_higher_or_equal(int prio1, int prio2)
	{
	return _is_prio1_higher_than_or_equal_to_prio2(prio1, prio2);
	}

	static inline int _is_prio1_higher_than_prio2(int prio1, int prio2)
	{
	return prio1 < prio2;
	}

	static inline int _is_prio_higher(int prio, int test_prio)
	{
	return _is_prio1_higher_than_prio2(prio, test_prio);
	}

	static inline int _is_prio1_lower_than_or_equal_to_prio2(int prio1, int prio2)
	{
	return prio1 >= prio2;
	}

	static inline int _is_prio_lower_or_equal(int prio1, int prio2)
	{
	return _is_prio1_lower_than_or_equal_to_prio2(prio1, prio2);
	}

	static inline int _is_prio1_lower_than_prio2(int prio1, int prio2)
	{
	return prio1 > prio2;
	}

	static inline int _is_prio_lower(int prio1, int prio2)
	{
	return _is_prio1_lower_than_prio2(prio1, prio2);
	}

	static inline int _is_t1_higher_prio_than_t2(struct k_thread *t1,
	struct k_thread *t2)
	{
	return _is_prio1_higher_than_prio2(t1->base.prio, t2->base.prio);
	}

	static inline int _is_higher_prio_than_current(struct k_thread *thread)
	{
	return _is_t1_higher_prio_than_t2(thread, _current);
	}

	/* is thread currenlty cooperative ? */
	static inline int _is_coop(struct k_thread *thread)
	{
	return thread->base.prio < 0;
	}

	/* is thread currently preemptible ? */
	static inline int _is_preempt(struct k_thread *thread)
	{
	return !_is_coop(thread) && !atomic_get(&thread->base.sched_locked);
	}

	/* is current thread preemptible and we are not running in ISR context */
	static inline int _is_current_execution_context_preemptible(void)
	{
	return !_is_in_isr() && _is_preempt(_current);
	}

	/* find out if priority is under priority inheritance ceiling */
	static inline int _is_under_prio_ceiling(int prio)
	{
	return prio >= CONFIG_PRIORITY_CEILING;
	}

	/*
	* Find out what priority to set a thread to taking the prio ceiling into
	* consideration.
	*/
	static inline int _get_new_prio_with_ceiling(int prio)
	{
	return _is_under_prio_ceiling(prio) ? prio : CONFIG_PRIORITY_CEILING;
	}

	/* find out the prio bitmap index for a given prio */
	static inline int _get_ready_q_prio_bmap_index(int prio)
	{
	return (prio + CONFIG_NUM_COOP_PRIORITIES) >> 5;
	}

	/* find out the prio bit for a given prio */
	static inline int _get_ready_q_prio_bit(int prio)
	{
	return (1 << ((prio + CONFIG_NUM_COOP_PRIORITIES) & 0x1f));
	}

	/* find out the ready queue array index for a given prio */
	static inline int _get_ready_q_q_index(int prio)
	{
	return prio + CONFIG_NUM_COOP_PRIORITIES;
	}

	#if (K_NUM_PRIORITIES > 32)
	#error not supported yet
	#endif

	/* find out the currently highest priority where a thread is ready to run */
	/* interrupts must be locked */
	static inline int _get_highest_ready_prio(void)
	{
	uint32_t ready = _ready_q.prio_bmap[0];

	return find_lsb_set(ready) - 1 - CONFIG_NUM_COOP_PRIORITIES;
	}

	/*
	* Checks if current thread must be context-switched out. The caller must
	* already know that the execution context is a thread.
	*/
	static inline int _must_switch_threads(void)
	{
	return _is_preempt(_current) && __must_switch_threads();
	}

	/*
	* Internal equivalent to k_sched_lock so that it does not incur a function
	* call penalty in the kernel guts.
	*
	* Must be kept in sync until the header files are cleaned-up and the
	* applications have access to the kernel internal deta structures (through
	* APIs of course).
	*/
	static inline void _sched_lock(void)
	{
	__ASSERT(!_is_in_isr(), "");

	atomic_inc(&_current->base.sched_locked);

	K_DEBUG("scheduler locked (%p:%d)\n",
	_current, _current->sched_locked);
	}

	/**
	* @brief Unlock the scheduler but do NOT reschedule
	*
	* It is incumbent upon the caller to ensure that the reschedule occurs
	* sometime after the scheduler is unlocked.
	*/
	static inline void _sched_unlock_no_reschedule(void)
	{
	__ASSERT(!_is_in_isr(), "");

	atomic_dec(&_current->base.sched_locked);
	}

	static inline void _set_thread_states(struct k_thread *thread, uint32_t states)
	{
	thread->base.flags \|= states;
	}

	static inline void _reset_thread_states(struct k_thread *thread,
	uint32_t states)
	{
	thread->base.flags &= ~states;
	}

	/* mark a thread as being suspended */
	static inline void _mark_thread_as_suspended(struct k_thread *thread)
	{
	thread->base.flags \|= K_SUSPENDED;
	}

	/* mark a thread as not being suspended */
	static inline void _mark_thread_as_not_suspended(struct k_thread *thread)
	{
	thread->base.flags &= ~K_SUSPENDED;
	}

	/* mark a thread as being in the timer queue */
	static inline void _mark_thread_as_timing(struct k_thread *thread)
	{
	thread->base.flags \|= K_TIMING;
	}

	/* mark a thread as not being in the timer queue */
	static inline void _mark_thread_as_not_timing(struct k_thread *thread)
	{
	thread->base.flags &= ~K_TIMING;
	}

	/* check if a thread is on the timer queue */
	static inline int _is_thread_timing(struct k_thread *thread)
	{
	return !!(thread->base.flags & K_TIMING);
	}

	static inline int _has_thread_started(struct k_thread *thread)
	{
	return !(thread->base.flags & K_PRESTART);
	}

	/* check if a thread is ready */
	static inline int _is_thread_ready(struct k_thread *thread)
	{
	return (thread->base.flags & K_EXECUTION_MASK) == K_READY;
	}

	/* mark a thread as pending in its TCS */
	static inline void _mark_thread_as_pending(struct k_thread *thread)
	{
	thread->base.flags \|= K_PENDING;
	}

	/* mark a thread as not pending in its TCS */
	static inline void _mark_thread_as_not_pending(struct k_thread *thread)
	{
	thread->base.flags &= ~K_PENDING;
	}

	/* check if a thread is pending */
	static inline int _is_thread_pending(struct k_thread *thread)
	{
	return !!(thread->base.flags & K_PENDING);
	}

	/*
	* Mark the thread as not being in the timer queue. If this makes it ready,
	* then add it to the ready queue according to its priority.
	*/
	/* must be called with interrupts locked */
	static inline void _ready_thread(struct k_thread *thread)
	{
	__ASSERT(_is_prio_higher(thread->base.prio, K_LOWEST_THREAD_PRIO) \|\|
	((thread->base.prio == K_LOWEST_THREAD_PRIO) &&
	(thread == _idle_thread)),
	"thread %p prio too low (is %d, cannot be lower than %d)",
	thread, thread->base.prio,
	thread == _idle_thread ? K_LOWEST_THREAD_PRIO :
	K_LOWEST_APPLICATION_THREAD_PRIO);

	__ASSERT(!_is_prio_higher(thread->base.prio, K_HIGHEST_THREAD_PRIO),
	"thread %p prio too high (id %d, cannot be higher than %d)",
	thread, thread->base.prio, K_HIGHEST_THREAD_PRIO);

	/* K_PRESTART is needed to handle the start-with-delay case */
	_reset_thread_states(thread, K_TIMING\|K_PRESTART);

	if (_is_thread_ready(thread)) {
	_add_thread_to_ready_q(thread);
	}
	}

	/**
	* @brief Mark a thread as started
	*
	* This routine must be called with interrupts locked.
	*/
	static inline void _mark_thread_as_started(struct k_thread *thread)
	{
	thread->base.flags &= ~K_PRESTART;
	}

	/**
	* @brief Mark thread as dead
	*
	* This routine must be called with interrupts locked.
	*/
	static inline void _mark_thread_as_dead(struct k_thread *thread)
	{
	thread->base.flags \|= K_DEAD;
	}

	/*
	* Set a thread's priority. If the thread is ready, place it in the correct
	* queue.
	*/
	/* must be called with interrupts locked */
	static inline void _thread_priority_set(struct k_thread *thread, int prio)
	{
	if (_is_thread_ready(thread)) {
	_remove_thread_from_ready_q(thread);
	thread->base.prio = prio;
	_add_thread_to_ready_q(thread);
	} else {
	thread->base.prio = prio;
	}
	}

	/* check if thread is a thread pending on a particular wait queue */
	static inline struct k_thread _peek_first_pending_thread(_wait_q_t wait_q)
	{
	return (struct k_thread *)sys_dlist_peek_head(wait_q);
	}

	/* unpend the first thread from a wait queue */
	static inline struct k_thread _unpend_first_thread(_wait_q_t wait_q)
	{
	struct k_thread thread = (struct k_thread )sys_dlist_get(wait_q);

	if (thread) {
	_mark_thread_as_not_pending(thread);
	}

	return thread;
	}

	/* Unpend a thread from the wait queue it is on. Thread must be pending. */
	/* must be called with interrupts locked */
	static inline void _unpend_thread(struct k_thread *thread)
	{
	__ASSERT(thread->base.flags & K_PENDING, "");

	sys_dlist_remove(&thread->base.k_q_node);
	_mark_thread_as_not_pending(thread);
	}

	#endif /* _ksched__h_ */