[PATCH v4] Pre-Release Strong-APA
Richi Dubey
richidubey at gmail.com
Wed Aug 26 20:37:20 UTC 2020
I've been trying to send the v4 but the patch keeps coming in v3 mail
thread :(.
What am I missing?
On Thu, Aug 27, 2020 at 2:03 AM Richi Dubey <richidubey at gmail.com> wrote:
> ---
> cpukit/include/rtems/scheduler.h | 6 +-
> .../include/rtems/score/schedulerstrongapa.h | 152 ++-
> cpukit/score/src/schedulerstrongapa.c | 901 ++++++++++++++----
> 3 files changed, 828 insertions(+), 231 deletions(-)
>
> diff --git a/cpukit/include/rtems/scheduler.h
> b/cpukit/include/rtems/scheduler.h
> index 955a83cfb4..6a05c2798a 100644
> --- a/cpukit/include/rtems/scheduler.h
> +++ b/cpukit/include/rtems/scheduler.h
> @@ -257,16 +257,14 @@
> #define RTEMS_SCHEDULER_STRONG_APA( name, prio_count ) \
> static struct { \
> Scheduler_strong_APA_Context Base; \
> - Chain_Control Ready[ ( prio_count ) ]; \
> + Scheduler_strong_APA_CPU CPU[ CONFIGURE_MAXIMUM_PROCESSORS ]; \
> } SCHEDULER_STRONG_APA_CONTEXT_NAME( name )
>
> #define RTEMS_SCHEDULER_TABLE_STRONG_APA( name, obj_name ) \
> { \
> &SCHEDULER_STRONG_APA_CONTEXT_NAME( name ).Base.Base.Base, \
> SCHEDULER_STRONG_APA_ENTRY_POINTS, \
> - RTEMS_ARRAY_SIZE( \
> - SCHEDULER_STRONG_APA_CONTEXT_NAME( name ).Ready \
> - ) - 1, \
> + SCHEDULER_STRONG_APA_MAXIMUM_PRIORITY, \
> ( obj_name ) \
> SCHEDULER_CONTROL_IS_NON_PREEMPT_MODE_SUPPORTED( false ) \
> }
> diff --git a/cpukit/include/rtems/score/schedulerstrongapa.h
> b/cpukit/include/rtems/score/schedulerstrongapa.h
> index 0ac28cb439..cfd79e932a 100644
> --- a/cpukit/include/rtems/score/schedulerstrongapa.h
> +++ b/cpukit/include/rtems/score/schedulerstrongapa.h
> @@ -6,31 +6,47 @@
> * @brief Strong APA Scheduler API
> */
>
> -/*
> - * Copyright (c) 2013, 2018 embedded brains GmbH. All rights reserved.
> +/* SPDX-License-Identifier: BSD-2-Clause
> *
> - * embedded brains GmbH
> - * Dornierstr. 4
> - * 82178 Puchheim
> - * Germany
> - * <rtems at embedded-brains.de>
> + * Copyright (C) 2020 Richi Dubey
> + * Copyright (c) 2013, 2018 embedded brains GmbH
> *
> - * The license and distribution terms for this file may be
> - * found in the file LICENSE in this distribution or at
> - * http://www.rtems.org/license/LICENSE.
> + * Redistribution and use in source and binary forms, with or without
> + * modification, are permitted provided that the following conditions
> + * are met:
> + * 1. Redistributions of source code must retain the above copyright
> + * notice, this list of conditions and the following disclaimer.
> + * 2. Redistributions in binary form must reproduce the above copyright
> + * notice, this list of conditions and the following disclaimer in the
> + * documentation and/or other materials provided with the distribution.
> + *
> + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> "AS IS"
> + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
> THE
> + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
> PURPOSE
> + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
> BE
> + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
> + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
> + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
> BUSINESS
> + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
> THE
> + * POSSIBILITY OF SUCH DAMAGE.
> */
>
> #ifndef _RTEMS_SCORE_SCHEDULERSTRONGAPA_H
> #define _RTEMS_SCORE_SCHEDULERSTRONGAPA_H
>
> #include <rtems/score/scheduler.h>
> -#include <rtems/score/schedulerpriority.h>
> #include <rtems/score/schedulersmp.h>
> +#include <rtems/score/percpu.h>
>
> #ifdef __cplusplus
> extern "C" {
> #endif /* __cplusplus */
>
> +#define STRONG_SCHEDULER_NODE_OF_CHAIN( node ) \
> + RTEMS_CONTAINER_OF( node, Scheduler_strong_APA_Node, Ready_node )
> +
> /**
> * @defgroup RTEMSScoreSchedulerStrongAPA Strong APA Scheduler
> *
> @@ -38,42 +54,96 @@ extern "C" {
> *
> * @brief Strong APA Scheduler
> *
> - * This is an implementation of the global fixed priority scheduler
> (G-FP). It
> - * uses one ready chain per priority to ensure constant time insert
> operations.
> - * The scheduled chain uses linear insert operations and has at most
> processor
> - * count entries. Since the processor and priority count are constants
> all
> - * scheduler operations complete in a bounded execution time.
> - *
> - * The the_thread preempt mode will be ignored.
> + * This is an implementation of the Strong APA scheduler defined by
> + * Cerqueira et al. in Linux's Processor Affinity API, Refined:
> + * Shifting Real-Time Tasks Towards Higher Schedulability.
> *
> + * The scheduled and ready nodes are accessed via the
> + * Scheduler_strong_APA_Context::Ready which helps in backtracking when a
> + * node which is executing on a CPU gets blocked. New node is allocated to
> + * the cpu by checking all the executing nodes in the affinity set of the
> + * node and the subsequent nodes executing on the processors in its
> + * affinity set.
> * @{
> */
>
> /**
> - * @brief Scheduler context specialization for Strong APA
> - * schedulers.
> + * @brief Scheduler node specialization for Strong APA schedulers.
> */
> typedef struct {
> - Scheduler_SMP_Context Base;
> - Priority_bit_map_Control Bit_map;
> - Chain_Control Ready[ RTEMS_ZERO_LENGTH_ARRAY ];
> -} Scheduler_strong_APA_Context;
> + /**
> + * @brief SMP scheduler node.
> + */
> + Scheduler_SMP_Node Base;
> +
> + /**
> + * @brief Chain node for Scheduler_strong_APA_Context::Ready.
> + */
> + Chain_Node Ready_node;
> +
> + /**
> + * @brief CPU that this node would preempt in the backtracking part of
> + * _Scheduler_strong_APA_Get_highest_ready and
> + * _Scheduler_strong_APA_Do_Enqueue.
> + */
> + Per_CPU_Control *cpu_to_preempt;
> +
> + /**
> + * @brief The associated affinity set of this node.
> + */
> + Processor_mask Affinity;
> +} Scheduler_strong_APA_Node;
> +
>
> /**
> - * @brief Scheduler node specialization for Strong APA
> - * schedulers.
> + * @brief CPU related variables and a CPU_Control to implement BFS.
> + */
> +typedef struct
> +{
> + /**
> + * @brief CPU in a queue.
> + */
> + Per_CPU_Control *cpu;
> +
> + /**
> + * @brief The node that would preempt this CPU.
> + */
> + Scheduler_Node *preempting_node;
> +
> + /**
> + * @brief Whether or not this cpu has been added to the queue
> + * (visited in BFS).
> + */
> + bool visited;
> +
> + /**
> + * @brief The node currently executing on this cpu.
> + */
> + Scheduler_Node *executing;
> +} Scheduler_strong_APA_CPU;
> +
> + /**
> + * @brief Scheduler context and node definition for Strong APA scheduler.
> */
> typedef struct {
> + /**
> + * @brief @see Scheduler_SMP_Context.
> + */
> + Scheduler_SMP_Context Base;
> +
> /**
> - * @brief SMP scheduler node.
> + * @brief Chain of all the ready and scheduled nodes present in
> + * the Strong APA scheduler.
> */
> - Scheduler_SMP_Node Base;
> + Chain_Control Ready;
>
> /**
> - * @brief The associated ready queue of this node.
> + * @brief Struct with important variables for each cpu.
> */
> - Scheduler_priority_Ready_queue Ready_queue;
> -} Scheduler_strong_APA_Node;
> + Scheduler_strong_APA_CPU CPU[ RTEMS_ZERO_LENGTH_ARRAY ];
> +} Scheduler_strong_APA_Context;
> +
> +#define SCHEDULER_STRONG_APA_MAXIMUM_PRIORITY 255
>
> /**
> * @brief Entry points for the Strong APA Scheduler.
> @@ -100,8 +170,8 @@ typedef struct {
> _Scheduler_default_Release_job, \
> _Scheduler_default_Cancel_job, \
> _Scheduler_default_Tick, \
> - _Scheduler_SMP_Start_idle \
> - SCHEDULER_OPERATION_DEFAULT_GET_SET_AFFINITY \
> + _Scheduler_SMP_Start_idle, \
> + _Scheduler_strong_APA_Set_affinity \
> }
>
> /**
> @@ -168,7 +238,7 @@ void _Scheduler_strong_APA_Update_priority(
> /**
> * @brief Asks for help.
> *
> - * @param scheduler The scheduler control instance.
> + * @param scheduler The scheduler control instance.
> * @param the_thread The thread that asks for help.
> * @param node The node of @a the_thread.
> *
> @@ -246,6 +316,20 @@ void _Scheduler_strong_APA_Yield(
> Scheduler_Node *node
> );
>
> +/**
> + * @brief Sets the affinity .
> + *
> + * @param scheduler The scheduler control instance.
> + * @param the_thread The thread to yield.
> + * @param[in, out] node The node of @a the_thread.
> + */
> +bool _Scheduler_strong_APA_Set_affinity(
> + const Scheduler_Control *scheduler,
> + Thread_Control *thread,
> + Scheduler_Node *node_base,
> + const Processor_mask *affinity
> +);
> +
> /** @} */
>
> #ifdef __cplusplus
> diff --git a/cpukit/score/src/schedulerstrongapa.c
> b/cpukit/score/src/schedulerstrongapa.c
> index 924cd86412..429bbacece 100644
> --- a/cpukit/score/src/schedulerstrongapa.c
> +++ b/cpukit/score/src/schedulerstrongapa.c
> @@ -6,18 +6,31 @@
> * @brief Strong APA Scheduler Implementation
> */
>
> -/*
> - * Copyright (c) 2013, 2016 embedded brains GmbH. All rights reserved.
> +/* SPDX-License-Identifier: BSD-2-Clause
> + *
> + * Copyright (C) 2020 Richi Dubey
> + * Copyright (c) 2013, 2018 embedded brains GmbH
> *
> - * embedded brains GmbH
> - * Dornierstr. 4
> - * 82178 Puchheim
> - * Germany
> - * <rtems at embedded-brains.de>
> + * Redistribution and use in source and binary forms, with or without
> + * modification, are permitted provided that the following conditions
> + * are met:
> + * 1. Redistributions of source code must retain the above copyright
> + * notice, this list of conditions and the following disclaimer.
> + * 2. Redistributions in binary form must reproduce the above copyright
> + * notice, this list of conditions and the following disclaimer in the
> + * documentation and/or other materials provided with the distribution.
> *
> - * The license and distribution terms for this file may be
> - * found in the file LICENSE in this distribution or at
> - * http://www.rtems.org/license/LICENSE.
> + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> "AS IS"
> + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
> THE
> + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
> PURPOSE
> + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
> BE
> + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
> + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
> + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
> BUSINESS
> + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
> THE
> + * POSSIBILITY OF SUCH DAMAGE.
> */
>
> #ifdef HAVE_CONFIG_H
> @@ -25,301 +38,754 @@
> #endif
>
> #include <rtems/score/schedulerstrongapa.h>
> -#include <rtems/score/schedulerpriorityimpl.h>
> #include <rtems/score/schedulersmpimpl.h>
> +#include <rtems/score/assert.h>
>
> -static Scheduler_strong_APA_Context *_Scheduler_strong_APA_Get_self(
> - Scheduler_Context *context
> -)
> +static inline Scheduler_strong_APA_Context *
> +_Scheduler_strong_APA_Get_context( const Scheduler_Control *scheduler )
> +{
> + return (Scheduler_strong_APA_Context *) _Scheduler_Get_context(
> scheduler );
> +}
> +
> +static inline Scheduler_strong_APA_Context *
> +_Scheduler_strong_APA_Get_self( Scheduler_Context *context )
> {
> return (Scheduler_strong_APA_Context *) context;
> }
>
> -static Scheduler_strong_APA_Node *
> +static inline Scheduler_strong_APA_Node *
> _Scheduler_strong_APA_Node_downcast( Scheduler_Node *node )
> {
> return (Scheduler_strong_APA_Node *) node;
> }
>
> -static void _Scheduler_strong_APA_Move_from_scheduled_to_ready(
> +static inline void _Scheduler_strong_APA_Do_update(
> Scheduler_Context *context,
> - Scheduler_Node *scheduled_to_ready
> + Scheduler_Node *node,
> + Priority_Control new_priority
> )
> {
> - Scheduler_strong_APA_Context *self =
> - _Scheduler_strong_APA_Get_self( context );
> - Scheduler_strong_APA_Node *node =
> - _Scheduler_strong_APA_Node_downcast( scheduled_to_ready );
> -
> - _Chain_Extract_unprotected( &node->Base.Base.Node.Chain );
> - _Scheduler_priority_Ready_queue_enqueue_first(
> - &node->Base.Base.Node.Chain,
> - &node->Ready_queue,
> - &self->Bit_map
> - );
> + Scheduler_SMP_Node *smp_node;
> + (void) context;
> +
> + smp_node = _Scheduler_SMP_Node_downcast( node );
> + _Scheduler_SMP_Node_update_priority( smp_node, new_priority );
> }
>
> -static void _Scheduler_strong_APA_Move_from_ready_to_scheduled(
> +/*
> + * Returns true if the Strong APA scheduler has ready nodes
> + * available for scheduling.
> + */
> +static inline bool
> + _Scheduler_strong_APA_Has_ready( Scheduler_Context *context )
> +{
> + Scheduler_strong_APA_Context *self;
> + const Chain_Node *tail;
> + Chain_Node *next;
> + Scheduler_strong_APA_Node *node;
> +
> + self = _Scheduler_strong_APA_Get_self( context );
> + tail = _Chain_Immutable_tail( &self->Ready );
> + next = _Chain_First( &self->Ready );
> +
> + while ( next != tail ) {
> + node = (Scheduler_strong_APA_Node *) STRONG_SCHEDULER_NODE_OF_CHAIN(
> next );
> +
> + if (
> + _Scheduler_SMP_Node_state( &node->Base.Base ) ==
> + SCHEDULER_SMP_NODE_READY
> + ) {
> + return true;
> + }
> +
> + next = _Chain_Next( next );
> + }
> +
> + return false;
> +}
> +
> +static inline void _Scheduler_strong_APA_Allocate_processor(
> Scheduler_Context *context,
> - Scheduler_Node *ready_to_scheduled
> + Scheduler_Node *scheduled_base,
> + Scheduler_Node *victim_base,
> + Per_CPU_Control *victim_cpu
> )
> {
> + Scheduler_strong_APA_Node *scheduled;
> Scheduler_strong_APA_Context *self;
> - Scheduler_strong_APA_Node *node;
> - Priority_Control insert_priority;
>
> + (void) victim_base;
> +
> + scheduled = _Scheduler_strong_APA_Node_downcast( scheduled_base );
> self = _Scheduler_strong_APA_Get_self( context );
> - node = _Scheduler_strong_APA_Node_downcast( ready_to_scheduled );
>
> - _Scheduler_priority_Ready_queue_extract(
> - &node->Base.Base.Node.Chain,
> - &node->Ready_queue,
> - &self->Bit_map
> + self->CPU[ _Per_CPU_Get_index( victim_cpu ) ].executing =
> scheduled_base;
> +
> + _Scheduler_SMP_Allocate_processor_exact(
> + context,
> + &(scheduled->Base.Base),
> + NULL,
> + victim_cpu
> );
> - insert_priority = _Scheduler_SMP_Node_priority( &node->Base.Base );
> +}
> +
> +/*
> + * Finds and returns the highest ready node present by accessing the
> + * _Strong_APA_Context->CPU with front and rear values.
> + */
> +
> +static inline Scheduler_Node * _Scheduler_strong_APA_Find_highest_ready(
> + Scheduler_strong_APA_Context *self,
> + uint32_t front,
> + uint32_t rear
> +)
> +{
> + Scheduler_Node *highest_ready;
> + Scheduler_strong_APA_CPU *CPU;
> + const Chain_Node *tail;
> + Chain_Node *next;
> + uint32_t index_assigned_cpu;
> + Scheduler_strong_APA_Node *node;
> + Priority_Control min_priority_num;
> + Priority_Control curr_priority;
> + Per_CPU_Control *assigned_cpu;
> + Scheduler_SMP_Node_state curr_state;
> + Per_CPU_Control *curr_CPU;
> + bool first_task;
> +
> + CPU = self->CPU;
> + /*
> + * When the first task accessed has nothing to compare its priority
> against
> + * So, it is the task with the highest priority witnessed so far.
> + */
> + first_task = true;
> +
> + //Assert rear < sizeof(Context->CPU)
> + _Assert( rear < CONFIGURE_MAXIMUM_PROCESSOR );
> +
> + while( front <= rear ) {
> + curr_CPU = CPU[ front ].cpu;
> + front = front + 1;
> +
> + tail = _Chain_Immutable_tail( &self->Ready );
> + next = _Chain_First( &self->Ready );
> +
> + while ( next != tail ) {
> + node = (Scheduler_strong_APA_Node*) STRONG_SCHEDULER_NODE_OF_CHAIN(
> next );
> + //Check if the curr_CPU is in the affinity set of the node.
> + if (
> + _Processor_mask_Is_set(&node->Affinity,
> _Per_CPU_Get_index(curr_CPU))
> + ) {
> + curr_state = _Scheduler_SMP_Node_state( &node->Base.Base );
> +
> + if ( curr_state == SCHEDULER_SMP_NODE_SCHEDULED ) {
> + assigned_cpu = _Thread_Get_CPU( node->Base.Base.user );
> + index_assigned_cpu = _Per_CPU_Get_index( assigned_cpu );
> +
> + if ( CPU[ index_assigned_cpu ].visited == false ) {
> + rear = rear + 1;
> + CPU[ rear ].cpu = assigned_cpu;
> + CPU[ index_assigned_cpu ].visited = true;
> + /*
> + * The curr CPU of the queue invoked this node to add its CPU
> + * that it is executing on to the queue. So this node might
> get
> + * preempted because of the invoker curr_CPU and this curr_CPU
> + * is the CPU that node should preempt in case this node
> + * gets preempted.
> + */
> + node->cpu_to_preempt = curr_CPU;
> + }
> + }
> + else if ( curr_state == SCHEDULER_SMP_NODE_READY ) {
> + curr_priority = _Scheduler_Node_get_priority( &node->Base.Base
> );
> + curr_priority = SCHEDULER_PRIORITY_PURIFY( curr_priority );
> +
> + if ( first_task == true || curr_priority < min_priority_num ) {
> + min_priority_num = curr_priority;
> + highest_ready = &node->Base.Base;
> + first_task = false;
> + /*
> + * In case curr_CPU is filter_CPU, we need to store the
> + * cpu_to_preempt value so that we go back to SMP_*
> + * function, rather than preempting the node ourselves.
> + */
> + node->cpu_to_preempt = curr_CPU;
> + }
> + }
> + }
> + next = _Chain_Next( next );
> + }
> + }
> +
> + return highest_ready;
> +}
> +
> +static inline void _Scheduler_strong_APA_Move_from_ready_to_scheduled(
> + Scheduler_Context *context,
> + Scheduler_Node *ready_to_scheduled
> +)
> +{
> + Priority_Control insert_priority;
> +
> + insert_priority = _Scheduler_SMP_Node_priority( ready_to_scheduled );
> insert_priority = SCHEDULER_PRIORITY_APPEND( insert_priority );
> - _Chain_Insert_ordered_unprotected(
> - &self->Base.Scheduled,
> - &node->Base.Base.Node.Chain,
> - &insert_priority,
> - _Scheduler_SMP_Priority_less_equal
> + _Scheduler_SMP_Insert_scheduled(
> + context,
> + ready_to_scheduled,
> + insert_priority
> );
> }
>
> -static void _Scheduler_strong_APA_Insert_ready(
> +/*
> + * Implement the BFS Algorithm for task departure to get the highest
> ready task
> + * for a particular CPU, returns the highest ready Scheduler_Node
> + * Scheduler_Node filter here pointst to the victim node that is blocked
> + * resulting which this function is called.
> + */
> +static inline Scheduler_Node *_Scheduler_strong_APA_Get_highest_ready(
> Scheduler_Context *context,
> - Scheduler_Node *node_base,
> - Priority_Control insert_priority
> + Scheduler_Node *filter
> )
> {
> Scheduler_strong_APA_Context *self;
> + Per_CPU_Control *filter_cpu;
> Scheduler_strong_APA_Node *node;
> + Scheduler_Node *highest_ready;
> + Scheduler_Node *curr_node;
> + Scheduler_Node *next_node;
> + Scheduler_strong_APA_CPU *CPU;
> + uint32_t front;
> + uint32_t rear;
> + uint32_t cpu_max;
> + uint32_t cpu_index;
>
> self = _Scheduler_strong_APA_Get_self( context );
> - node = _Scheduler_strong_APA_Node_downcast( node_base );
> + //Denotes front and rear of the queue.
> + front = 0;
> + rear = -1;
>
> - if ( SCHEDULER_PRIORITY_IS_APPEND( insert_priority ) ) {
> - _Scheduler_priority_Ready_queue_enqueue(
> - &node->Base.Base.Node.Chain,
> - &node->Ready_queue,
> - &self->Bit_map
> - );
> - } else {
> - _Scheduler_priority_Ready_queue_enqueue_first(
> - &node->Base.Base.Node.Chain,
> - &node->Ready_queue,
> - &self->Bit_map
> - );
> + filter_cpu = _Thread_Get_CPU( filter->user );
> + CPU = self->CPU;
> + cpu_max = _SMP_Get_processor_maximum();
> +
> + for ( cpu_index = 0 ; cpu_index < cpu_max ; ++cpu_index ) {
> + CPU[ cpu_index ].visited = false;
> }
> +
> + rear = rear + 1;
> + CPU[ rear ].cpu = filter_cpu;
> + CPU[ _Per_CPU_Get_index( filter_cpu ) ].visited = true;
> +
> + highest_ready = _Scheduler_strong_APA_Find_highest_ready(
> + self,
> + front,
> + rear
> + );
> +
> + if ( highest_ready != filter ) {
> + /*
> + * Backtrack on the path from
> + * filter_cpu to highest_ready, shifting along every task.
> + */
> +
> + node = _Scheduler_strong_APA_Node_downcast( highest_ready );
> + /*
> + * Highest ready is not just directly reachable from the victim cpu
> + * So there is need of task shifting .
> + */
> + while( node->cpu_to_preempt != filter_cpu ){
> + curr_node = &node->Base.Base;
> + next_node = CPU[ _Per_CPU_Get_index( node->cpu_to_preempt )
> ].executing;
> +
> + _Scheduler_SMP_Preempt(
> + context,
> + curr_node,
> + next_node,
> + _Scheduler_strong_APA_Allocate_processor
> + );
> +
> + if( curr_node == highest_ready) {
> + _Scheduler_strong_APA_Move_from_ready_to_scheduled(context,
> curr_node);
> + }
> +
> + node = _Scheduler_strong_APA_Node_downcast( next_node );
> + }
> + /*
> + * To save the last node so that the caller SMP_* function
> + * can do the allocation
> + */
> + curr_node = &node->Base.Base;
> + highest_ready = curr_node;
> + }
> +
> + return highest_ready;
> }
>
> -static void _Scheduler_strong_APA_Extract_from_ready(
> +/*
> + * Checks the lowest scheduled directly reachable task
> + */
> +static inline Scheduler_Node *_Scheduler_strong_APA_Get_lowest_scheduled(
> Scheduler_Context *context,
> - Scheduler_Node *the_thread
> + Scheduler_Node *filter_base
> )
> {
> - Scheduler_strong_APA_Context *self =
> - _Scheduler_strong_APA_Get_self( context );
> - Scheduler_strong_APA_Node *node =
> - _Scheduler_strong_APA_Node_downcast( the_thread );
> -
> - _Scheduler_priority_Ready_queue_extract(
> - &node->Base.Base.Node.Chain,
> - &node->Ready_queue,
> - &self->Bit_map
> - );
> + uint32_t cpu_max;
> + uint32_t cpu_index;
> + Scheduler_Node *curr_node;
> + Scheduler_Node *lowest_scheduled;
> + Priority_Control max_priority_num;
> + Priority_Control curr_priority;
> + Scheduler_strong_APA_Node *filter_strong_node;
> + Scheduler_strong_APA_Context *self;
> +
> + self = _Scheduler_strong_APA_Get_self( context );
> + lowest_scheduled = NULL; // To remove compiler warning.
> + max_priority_num = 0; // Max (Lowest) priority encountered so far.
> + filter_strong_node = _Scheduler_strong_APA_Node_downcast( filter_base );
> +
> + //lowest_scheduled is NULL if affinty of a node is 0
> + _Assert( !_Processor_mask_Zero( &filter_strong_node->Affinity ) );
> + cpu_max = _SMP_Get_processor_maximum();
> +
> + for ( cpu_index = 0 ; cpu_index < cpu_max ; ++cpu_index ) {
> + //Checks if the CPU is in the affinity set of filter_strong_node
> + if ( _Processor_mask_Is_set( &filter_strong_node->Affinity,
> cpu_index) ) {
> + Per_CPU_Control *cpu = _Per_CPU_Get_by_index( cpu_index );
> +
> + if ( _Per_CPU_Is_processor_online( cpu ) ) {
> + curr_node = self->CPU[ _Per_CPU_Get_index( cpu ) ].executing;
> + curr_priority = _Scheduler_Node_get_priority( curr_node );
> + curr_priority = SCHEDULER_PRIORITY_PURIFY( curr_priority );
> +
> + if ( curr_priority > max_priority_num ) {
> + lowest_scheduled = curr_node;
> + max_priority_num = curr_priority;
> + }
> + }
> + }
> + }
> +
> + _Assert( lowest_scheduled != NULL );
> + return lowest_scheduled;
> }
>
> -static void _Scheduler_strong_APA_Do_update(
> +static inline void _Scheduler_strong_APA_Extract_from_scheduled(
> Scheduler_Context *context,
> - Scheduler_Node *node_to_update,
> - Priority_Control new_priority
> + Scheduler_Node *node_to_extract
> )
> {
> - Scheduler_strong_APA_Context *self =
> - _Scheduler_strong_APA_Get_self( context );
> - Scheduler_strong_APA_Node *node =
> - _Scheduler_strong_APA_Node_downcast( node_to_update );
> -
> - _Scheduler_SMP_Node_update_priority( &node->Base, new_priority );
> - _Scheduler_priority_Ready_queue_update(
> - &node->Ready_queue,
> - SCHEDULER_PRIORITY_UNMAP( new_priority ),
> - &self->Bit_map,
> - &self->Ready[ 0 ]
> - );
> + Scheduler_strong_APA_Context *self;
> + Scheduler_strong_APA_Node *node;
> +
> + self = _Scheduler_strong_APA_Get_self( context );
> + node = _Scheduler_strong_APA_Node_downcast( node_to_extract );
> +
> + _Scheduler_SMP_Extract_from_scheduled( &self->Base.Base,
> &node->Base.Base );
> + //Not removing it from Ready since the node could go in the READY state.
> }
>
> -static Scheduler_strong_APA_Context *
> -_Scheduler_strong_APA_Get_context( const Scheduler_Control *scheduler )
> +static inline void _Scheduler_strong_APA_Extract_from_ready(
> + Scheduler_Context *context,
> + Scheduler_Node *node_to_extract
> +)
> {
> - return (Scheduler_strong_APA_Context *) _Scheduler_Get_context(
> scheduler );
> + Scheduler_strong_APA_Context *self;
> + Scheduler_strong_APA_Node *node;
> +
> + self = _Scheduler_strong_APA_Get_self( context );
> + node = _Scheduler_strong_APA_Node_downcast( node_to_extract );
> +
> + _Assert( !_Chain_Is_empty(self->Ready) );
> + _Assert( !_Chain_Is_node_off_chain( &node->Ready_node ) );
> +
> + _Chain_Extract_unprotected( &node->Ready_node ); //Removed from
> Ready
> + _Chain_Set_off_chain( &node->Ready_node );
> }
>
> -void _Scheduler_strong_APA_Initialize( const Scheduler_Control *scheduler
> )
> +static inline void _Scheduler_strong_APA_Insert_ready(
> + Scheduler_Context *context,
> + Scheduler_Node *node_base,
> + Priority_Control insert_priority
> +)
> {
> - Scheduler_strong_APA_Context *self =
> - _Scheduler_strong_APA_Get_context( scheduler );
> + Scheduler_strong_APA_Context *self;
> + Scheduler_strong_APA_Node *node;
>
> - _Scheduler_SMP_Initialize( &self->Base );
> - _Priority_bit_map_Initialize( &self->Bit_map );
> - _Scheduler_priority_Ready_queue_initialize(
> - &self->Ready[ 0 ],
> - scheduler->maximum_priority
> - );
> + self = _Scheduler_strong_APA_Get_self( context );
> + node = _Scheduler_strong_APA_Node_downcast( node_base );
> +
> + if( _Chain_Is_node_off_chain( &node->Ready_node ) ) {
> + _Chain_Append_unprotected( &self->Ready, &node->Ready_node );
> + }
> }
>
> -void _Scheduler_strong_APA_Node_initialize(
> - const Scheduler_Control *scheduler,
> - Scheduler_Node *node,
> - Thread_Control *the_thread,
> - Priority_Control priority
> +static inline void _Scheduler_strong_APA_Move_from_scheduled_to_ready(
> + Scheduler_Context *context,
> + Scheduler_Node *scheduled_to_ready
> )
> {
> - Scheduler_Context *context;
> - Scheduler_strong_APA_Context *self;
> - Scheduler_strong_APA_Node *the_node;
> + Priority_Control insert_priority;
>
> - the_node = _Scheduler_strong_APA_Node_downcast( node );
> - _Scheduler_SMP_Node_initialize(
> - scheduler,
> - &the_node->Base,
> - the_thread,
> - priority
> - );
> + _Scheduler_SMP_Extract_from_scheduled( context, scheduled_to_ready );
> + insert_priority = _Scheduler_SMP_Node_priority( scheduled_to_ready );
>
> - context = _Scheduler_Get_context( scheduler );
> - self = _Scheduler_strong_APA_Get_self( context );
> - _Scheduler_priority_Ready_queue_update(
> - &the_node->Ready_queue,
> - SCHEDULER_PRIORITY_UNMAP( priority ),
> - &self->Bit_map,
> - &self->Ready[ 0 ]
> + _Scheduler_strong_APA_Insert_ready(
> + context,
> + scheduled_to_ready,
> + insert_priority
> );
> }
>
> -static bool _Scheduler_strong_APA_Has_ready( Scheduler_Context *context )
> +static inline Scheduler_Node* _Scheduler_strong_APA_Get_lowest_reachable(
> + Scheduler_strong_APA_Context *self,
> + uint32_t front,
> + uint32_t rear,
> + Per_CPU_Control **cpu_to_preempt
> +)
> {
> - Scheduler_strong_APA_Context *self =
> - _Scheduler_strong_APA_Get_self( context );
> + Scheduler_Node *lowest_reachable;
> + Priority_Control max_priority_num;
> + uint32_t cpu_max;
> + uint32_t cpu_index;
> + Thread_Control *curr_thread;
> + Per_CPU_Control *curr_CPU;
> + Priority_Control curr_priority;
> + Scheduler_Node *curr_node;
> + Scheduler_strong_APA_Node *curr_strong_node; //Current Strong_APA_Node
> + Scheduler_strong_APA_CPU *CPU;
> +
> + max_priority_num = 0; //Max (Lowest) priority encountered so far.
> + CPU = self->CPU;
> + cpu_max = _SMP_Get_processor_maximum();
> +
> + while( front <= rear ) {
> + curr_CPU = CPU[ front ].cpu;
> + front = front + 1;
> +
> + curr_node = CPU[ _Per_CPU_Get_index( curr_CPU ) ].executing;
> + curr_thread = curr_node->user;
> +
> + curr_priority = _Scheduler_Node_get_priority( curr_node );
> + curr_priority = SCHEDULER_PRIORITY_PURIFY( curr_priority );
> +
> + curr_strong_node = _Scheduler_strong_APA_Node_downcast( curr_node );
> +
> + if ( curr_priority > max_priority_num ) {
> + lowest_reachable = curr_node;
> + max_priority_num = curr_priority;
> + *cpu_to_preempt = curr_CPU;
> + }
> +
> + if ( !curr_thread->is_idle ) {
> + for ( cpu_index = 0 ; cpu_index < cpu_max ; ++cpu_index ) {
> + if ( _Processor_mask_Is_set( &curr_strong_node->Affinity,
> cpu_index ) ) {
> + //Checks if the thread_CPU is in the affinity set of the node
> + Per_CPU_Control *cpu = _Per_CPU_Get_by_index( cpu_index );
> + if ( _Per_CPU_Is_processor_online( cpu ) && CPU[ cpu_index
> ].visited == false ) {
> + rear = rear + 1;
> + CPU[ rear ].cpu = cpu;
> + CPU[ cpu_index ].visited = true;
> + CPU[ cpu_index ].preempting_node = curr_node;
> + }
> + }
> + }
> + }
> + }
>
> - return !_Priority_bit_map_Is_empty( &self->Bit_map );
> + return lowest_reachable;
> }
>
> -static Scheduler_Node *_Scheduler_strong_APA_Get_highest_ready(
> +static inline bool _Scheduler_strong_APA_Do_enqueue(
> Scheduler_Context *context,
> - Scheduler_Node *node
> + Scheduler_Node *lowest_reachable,
> + Scheduler_Node *node,
> + Priority_Control insert_priority,
> + Per_CPU_Control *cpu_to_preempt
> )
> {
> - Scheduler_strong_APA_Context *self =
> - _Scheduler_strong_APA_Get_self( context );
> + bool needs_help;
> + Priority_Control node_priority;
> + Priority_Control lowest_priority;
> + Scheduler_strong_APA_CPU *CPU;
> + Scheduler_Node *curr_node;
> + Scheduler_strong_APA_Node *curr_strong_node; //Current
> Strong_APA_Node
> + Per_CPU_Control *curr_CPU;
> + Scheduler_strong_APA_Context *self;
> + Scheduler_Node *next_node;
> +
> + self = _Scheduler_strong_APA_Get_self( context );
> + CPU = self->CPU;
> +
> + node_priority = _Scheduler_Node_get_priority( node );
> + node_priority = SCHEDULER_PRIORITY_PURIFY( node_priority );
> +
> + lowest_priority = _Scheduler_Node_get_priority( lowest_reachable );
> + lowest_priority = SCHEDULER_PRIORITY_PURIFY( lowest_priority );
> +
> + if( lowest_priority > node_priority ) {
> + //Backtrack on the path from
> + //_Thread_Get_CPU(lowest_reachable->user) to lowest_reachable,
> shifting
> + //along every task
> +
> + curr_node = CPU[ _Per_CPU_Get_index(cpu_to_preempt) ].preempting_node;
> + curr_strong_node = _Scheduler_strong_APA_Node_downcast( curr_node );
> + curr_strong_node->cpu_to_preempt = cpu_to_preempt;
> +
> + //Save which cpu to preempt in cpu_to_preempt value of the node
> + while ( curr_node != node ) {
> + curr_CPU = _Thread_Get_CPU( curr_node->user );
> + curr_node = CPU[ _Per_CPU_Get_index( curr_CPU ) ].preempting_node;
> + curr_strong_node = _Scheduler_strong_APA_Node_downcast( curr_node );
> + curr_strong_node->cpu_to_preempt = curr_CPU;
> + }
> +
> + curr_CPU = curr_strong_node->cpu_to_preempt;
> + next_node = CPU[ _Per_CPU_Get_index( curr_CPU ) ].executing;
> +
> + node_priority = _Scheduler_Node_get_priority( curr_node );
> + node_priority = SCHEDULER_PRIORITY_PURIFY( node_priority );
> +
> + _Scheduler_SMP_Enqueue_to_scheduled(
> + context,
> + curr_node,
> + node_priority,
> + next_node,
> + _Scheduler_SMP_Insert_scheduled,
> + _Scheduler_strong_APA_Move_from_scheduled_to_ready,
> + _Scheduler_strong_APA_Allocate_processor
> + );
>
> - (void) node;
> + curr_node = next_node;
> + curr_strong_node = _Scheduler_strong_APA_Node_downcast( curr_node );
>
> - return (Scheduler_Node *) _Scheduler_priority_Ready_queue_first(
> - &self->Bit_map,
> - &self->Ready[ 0 ]
> - );
> + while( curr_node != lowest_reachable ) {
> + curr_CPU = curr_strong_node->cpu_to_preempt;
> + next_node = CPU[ _Per_CPU_Get_index( curr_CPU ) ].executing;
> + //curr_node preempts the next_node;
> + _Scheduler_SMP_Preempt(
> + context,
> + curr_node,
> + next_node,
> + _Scheduler_strong_APA_Allocate_processor
> + );
> +
> + curr_node = next_node;
> + curr_strong_node = _Scheduler_strong_APA_Node_downcast( curr_node );
> + }
> +
> + _Scheduler_strong_APA_Move_from_scheduled_to_ready( context,
> lowest_reachable );
> +
> + needs_help = false;
> + } else {
> + needs_help = true;
> + }
> +
> + //Add it to Ready chain since it is now either scheduled or just ready.
> + _Scheduler_strong_APA_Insert_ready(context,node,insert_priority);
> +
> + return needs_help;
> }
>
> -void _Scheduler_strong_APA_Block(
> - const Scheduler_Control *scheduler,
> - Thread_Control *the_thread,
> - Scheduler_Node *node
> +/*
> + * BFS Algorithm for task arrival
> + * Enqueue node either in the scheduled chain or in the ready chain.
> + * node is the newly arrived node and is currently not scheduled.
> + */
> +static inline bool _Scheduler_strong_APA_Enqueue(
> + Scheduler_Context *context,
> + Scheduler_Node *node,
> + Priority_Control insert_priority
> )
> {
> - Scheduler_Context *context = _Scheduler_Get_context( scheduler );
> + Scheduler_strong_APA_Context *self;
> + Scheduler_strong_APA_CPU *CPU;
> + uint32_t cpu_max;
> + uint32_t cpu_index;
> + Per_CPU_Control *cpu_to_preempt;
> + Scheduler_Node *lowest_reachable;
> + Scheduler_strong_APA_Node *strong_node;
>
> - _Scheduler_SMP_Block(
> + //Denotes front and rear of the queue
> + uint32_t front;
> + uint32_t rear;
> +
> + front = 0;
> + rear = -1;
> +
> + self = _Scheduler_strong_APA_Get_self( context );
> + strong_node = _Scheduler_strong_APA_Node_downcast( node );
> + cpu_max = _SMP_Get_processor_maximum();
> + CPU = self->CPU;
> +
> + for ( cpu_index = 0 ; cpu_index < cpu_max ; ++cpu_index ) {
> + CPU[ cpu_index ].visited = false;
> +
> + //Checks if the thread_CPU is in the affinity set of the node
> + if ( _Processor_mask_Is_set( &strong_node->Affinity, cpu_index) ) {
> + Per_CPU_Control *cpu = _Per_CPU_Get_by_index( cpu_index );
> +
> + if ( _Per_CPU_Is_processor_online( cpu ) ) {
> + rear = rear + 1;
> + CPU[ rear ].cpu = cpu;
> + CPU[ cpu_index ].visited = true;
> + CPU[ cpu_index ].preempting_node = node;
> + }
> + }
> + }
> +
> + //This assert makes sure that there always exist an element in the
> + // Queue when we start the queue traversal.
> + _Assert( !_Processor_mask_Zero( &strong_node->Affinity ) );
> +
> + lowest_reachable = _Scheduler_strong_APA_Get_lowest_reachable(
> + self,
> + front,
> + rear,
> + &cpu_to_preempt
> + );
> +
> + return _Scheduler_strong_APA_Do_enqueue(
> + context,
> + lowest_reachable,
> + node,
> + insert_priority,
> + cpu_to_preempt
> + );
> +}
> +
> +static inline bool _Scheduler_strong_APA_Enqueue_scheduled(
> + Scheduler_Context *context,
> + Scheduler_Node *node,
> + Priority_Control insert_priority
> +)
> +{
> + return _Scheduler_SMP_Enqueue_scheduled(
> context,
> - the_thread,
> node,
> - _Scheduler_SMP_Extract_from_scheduled,
> + insert_priority,
> + _Scheduler_SMP_Priority_less_equal,
> _Scheduler_strong_APA_Extract_from_ready,
> _Scheduler_strong_APA_Get_highest_ready,
> + _Scheduler_strong_APA_Insert_ready,
> + _Scheduler_SMP_Insert_scheduled,
> _Scheduler_strong_APA_Move_from_ready_to_scheduled,
> - _Scheduler_SMP_Allocate_processor_exact
> + _Scheduler_strong_APA_Allocate_processor
> );
> }
>
> -static bool _Scheduler_strong_APA_Enqueue(
> +static inline bool _Scheduler_strong_APA_Do_ask_for_help(
> Scheduler_Context *context,
> - Scheduler_Node *node,
> - Priority_Control insert_priority
> + Thread_Control *the_thread,
> + Scheduler_Node *node
> )
> {
> - return _Scheduler_SMP_Enqueue(
> + return _Scheduler_SMP_Ask_for_help(
> context,
> + the_thread,
> node,
> - insert_priority,
> _Scheduler_SMP_Priority_less_equal,
> _Scheduler_strong_APA_Insert_ready,
> _Scheduler_SMP_Insert_scheduled,
> _Scheduler_strong_APA_Move_from_scheduled_to_ready,
> - _Scheduler_SMP_Get_lowest_scheduled,
> - _Scheduler_SMP_Allocate_processor_exact
> + _Scheduler_strong_APA_Get_lowest_scheduled,
> + _Scheduler_strong_APA_Allocate_processor
> );
> }
>
> -static bool _Scheduler_strong_APA_Enqueue_scheduled(
> +static inline void _Scheduler_strong_APA_Register_idle(
> Scheduler_Context *context,
> - Scheduler_Node *node,
> - Priority_Control insert_priority
> + Scheduler_Node *idle_base,
> + Per_CPU_Control *cpu
> )
> {
> - return _Scheduler_SMP_Enqueue_scheduled(
> + (void) context;
> + (void) idle_base;
> + (void) cpu;
> + /*
> + * We do not maintain a variable to access the scheduled
> + * node for a CPU. So this function does nothing.
> + */
> +}
> +
> +static inline void _Scheduler_strong_APA_Do_set_affinity(
> + Scheduler_Context *context,
> + Scheduler_Node *node_base,
> + void *arg
> +)
> +{
> + Scheduler_strong_APA_Node *node;
> +
> + node = _Scheduler_strong_APA_Node_downcast( node_base );
> + node->Affinity = *(( const Processor_mask *) arg);
> +}
> +
> +void _Scheduler_strong_APA_Initialize( const Scheduler_Control *scheduler
> )
> +{
> + Scheduler_strong_APA_Context *self =
> + _Scheduler_strong_APA_Get_context( scheduler );
> +
> + _Scheduler_SMP_Initialize( &self->Base );
> + _Chain_Initialize_empty( &self->Ready );
> +}
> +
> +void _Scheduler_strong_APA_Yield(
> + const Scheduler_Control *scheduler,
> + Thread_Control *thread,
> + Scheduler_Node *node
> +)
> +{
> + Scheduler_Context *context = _Scheduler_Get_context( scheduler );
> +
> + _Scheduler_SMP_Yield(
> context,
> + thread,
> node,
> - insert_priority,
> - _Scheduler_SMP_Priority_less_equal,
> _Scheduler_strong_APA_Extract_from_ready,
> - _Scheduler_strong_APA_Get_highest_ready,
> - _Scheduler_strong_APA_Insert_ready,
> - _Scheduler_SMP_Insert_scheduled,
> - _Scheduler_strong_APA_Move_from_ready_to_scheduled,
> - _Scheduler_SMP_Allocate_processor_exact
> + _Scheduler_strong_APA_Enqueue,
> + _Scheduler_strong_APA_Enqueue_scheduled
> );
> }
>
> -void _Scheduler_strong_APA_Unblock(
> +void _Scheduler_strong_APA_Block(
> const Scheduler_Control *scheduler,
> - Thread_Control *the_thread,
> + Thread_Control *thread,
> Scheduler_Node *node
> )
> {
> Scheduler_Context *context = _Scheduler_Get_context( scheduler );
> -
> - _Scheduler_SMP_Unblock(
> + //The extract from ready automatically removes the node from Ready
> chain.
> + _Scheduler_SMP_Block(
> context,
> - the_thread,
> + thread,
> node,
> - _Scheduler_strong_APA_Do_update,
> - _Scheduler_strong_APA_Enqueue
> + _Scheduler_strong_APA_Extract_from_scheduled,
> + _Scheduler_strong_APA_Extract_from_ready,
> + _Scheduler_strong_APA_Get_highest_ready,
> + _Scheduler_strong_APA_Move_from_ready_to_scheduled,
> + _Scheduler_strong_APA_Allocate_processor
> );
> }
>
> -static bool _Scheduler_strong_APA_Do_ask_for_help(
> - Scheduler_Context *context,
> - Thread_Control *the_thread,
> - Scheduler_Node *node
> +void _Scheduler_strong_APA_Unblock(
> + const Scheduler_Control *scheduler,
> + Thread_Control *thread,
> + Scheduler_Node *node
> )
> {
> - return _Scheduler_SMP_Ask_for_help(
> + Scheduler_Context *context = _Scheduler_Get_context( scheduler );
> +
> + _Scheduler_SMP_Unblock(
> context,
> - the_thread,
> + thread,
> node,
> - _Scheduler_SMP_Priority_less_equal,
> - _Scheduler_strong_APA_Insert_ready,
> - _Scheduler_SMP_Insert_scheduled,
> - _Scheduler_strong_APA_Move_from_scheduled_to_ready,
> - _Scheduler_SMP_Get_lowest_scheduled,
> - _Scheduler_SMP_Allocate_processor_lazy
> + _Scheduler_strong_APA_Do_update,
> + _Scheduler_strong_APA_Enqueue
> );
> }
>
> void _Scheduler_strong_APA_Update_priority(
> const Scheduler_Control *scheduler,
> - Thread_Control *the_thread,
> + Thread_Control *thread,
> Scheduler_Node *node
> )
> {
> @@ -327,7 +793,7 @@ void _Scheduler_strong_APA_Update_priority(
>
> _Scheduler_SMP_Update_priority(
> context,
> - the_thread,
> + thread,
> node,
> _Scheduler_strong_APA_Extract_from_ready,
> _Scheduler_strong_APA_Do_update,
> @@ -345,7 +811,11 @@ bool _Scheduler_strong_APA_Ask_for_help(
> {
> Scheduler_Context *context = _Scheduler_Get_context( scheduler );
>
> - return _Scheduler_strong_APA_Do_ask_for_help( context, the_thread, node
> );
> + return _Scheduler_strong_APA_Do_ask_for_help(
> + context,
> + the_thread,
> + node
> + );
> }
>
> void _Scheduler_strong_APA_Reconsider_help_request(
> @@ -381,7 +851,7 @@ void _Scheduler_strong_APA_Withdraw_node(
> _Scheduler_strong_APA_Extract_from_ready,
> _Scheduler_strong_APA_Get_highest_ready,
> _Scheduler_strong_APA_Move_from_ready_to_scheduled,
> - _Scheduler_SMP_Allocate_processor_lazy
> + _Scheduler_strong_APA_Allocate_processor
> );
> }
>
> @@ -416,20 +886,65 @@ Thread_Control
> *_Scheduler_strong_APA_Remove_processor(
> );
> }
>
> -void _Scheduler_strong_APA_Yield(
> +void _Scheduler_strong_APA_Node_initialize(
> const Scheduler_Control *scheduler,
> + Scheduler_Node *node,
> Thread_Control *the_thread,
> - Scheduler_Node *node
> + Priority_Control priority
> )
> {
> - Scheduler_Context *context = _Scheduler_Get_context( scheduler );
> + Scheduler_SMP_Node *smp_node;
> + Scheduler_strong_APA_Node *strong_node;
>
> - _Scheduler_SMP_Yield(
> - context,
> - the_thread,
> - node,
> - _Scheduler_strong_APA_Extract_from_ready,
> - _Scheduler_strong_APA_Enqueue,
> - _Scheduler_strong_APA_Enqueue_scheduled
> + smp_node = _Scheduler_SMP_Node_downcast( node );
> + strong_node = _Scheduler_strong_APA_Node_downcast( node );
> +
> + _Scheduler_SMP_Node_initialize( scheduler, smp_node, the_thread,
> priority );
> +
> + _Processor_mask_Assign(
> + &strong_node->Affinity,
> + _SMP_Get_online_processors()
> );
> }
> +
> +bool _Scheduler_strong_APA_Set_affinity(
> + const Scheduler_Control *scheduler,
> + Thread_Control *thread,
> + Scheduler_Node *node_base,
> + const Processor_mask *affinity
> +)
> +{
> + Scheduler_Context *context;
> + Scheduler_strong_APA_Node *node;
> + Processor_mask local_affinity;
> +
> + context = _Scheduler_Get_context( scheduler );
> + _Processor_mask_And( &local_affinity, &context->Processors, affinity );
> +
> + if ( _Processor_mask_Is_zero( &local_affinity ) ) {
> + return false;
> + }
> +
> + node = _Scheduler_strong_APA_Node_downcast( node_base );
> +
> + if ( _Processor_mask_Is_equal( &node->Affinity, affinity ) )
> + return true; //Nothing to do. Return true.
> +
> + _Processor_mask_Assign( &node->Affinity, &local_affinity );
> +
> + _Scheduler_SMP_Set_affinity(
> + context,
> + thread,
> + node_base,
> + &local_affinity,
> + _Scheduler_strong_APA_Do_set_affinity,
> + _Scheduler_strong_APA_Extract_from_ready,
> + _Scheduler_strong_APA_Get_highest_ready,
> + _Scheduler_strong_APA_Move_from_ready_to_scheduled,
> + _Scheduler_strong_APA_Enqueue,
> + _Scheduler_strong_APA_Allocate_processor
> + );
> +
> + return true;
> +}
> +
> --
> 2.17.1
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.rtems.org/pipermail/devel/attachments/20200827/d8639f04/attachment-0001.html>
More information about the devel
mailing list