/**************************************************************************/ /* */ /* Copyright (c) Microsoft Corporation. All rights reserved. */ /* */ /* This software is licensed under the Microsoft Software License */ /* Terms for Microsoft Azure RTOS. Full text of the license can be */ /* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */ /* and in the root directory of this software. */ /* */ /**************************************************************************/ /**************************************************************************/ /**************************************************************************/ /** */ /** ThreadX Component */ /** */ /** Thread */ /** */ /**************************************************************************/ /**************************************************************************/ #define TX_SOURCE_CODE #define TX_THREAD_SMP_SOURCE_CODE /* Include necessary system files. */ #include "tx_api.h" #include "tx_thread.h" #include "tx_timer.h" #include "tx_trace.h" /**************************************************************************/ /* */ /* FUNCTION RELEASE */ /* */ /* _tx_thread_relinquish PORTABLE SMP */ /* 6.1 */ /* AUTHOR */ /* */ /* William E. Lamie, Microsoft Corporation */ /* */ /* DESCRIPTION */ /* */ /* This function determines if there is another higher or equal */ /* priority, non-executing thread that can execute on this processor. */ /* such a thread is found, the calling thread relinquishes control. */ /* Otherwise, this function simply returns. */ /* */ /* INPUT */ /* */ /* None */ /* */ /* OUTPUT */ /* */ /* None */ /* */ /* CALLS */ /* */ /* _tx_thread_smp_rebalance_execute_list Rebalance the execution list */ /* _tx_thread_system_return Return to the system */ /* */ /* CALLED BY */ /* */ /* Application Code */ /* */ /* RELEASE HISTORY */ /* */ /* DATE NAME DESCRIPTION */ /* */ /* 09-30-2020 William E. Lamie Initial Version 6.1 */ /* */ /**************************************************************************/ VOID _tx_thread_relinquish(VOID) { TX_INTERRUPT_SAVE_AREA UINT priority; TX_THREAD *thread_ptr; TX_THREAD *head_ptr; TX_THREAD *tail_ptr; TX_THREAD *next_thread; TX_THREAD *previous_thread; UINT core_index; UINT rebalance; UINT mapped_core; ULONG excluded; #ifndef TX_DISABLE_PREEMPTION_THRESHOLD UINT base_priority; UINT priority_bit_set; UINT next_preempted; ULONG priority_bit; ULONG priority_map; TX_THREAD *preempted_thread; #if TX_MAX_PRIORITIES > 32 UINT map_index; #endif #endif UINT finished; /* Default finished to false. */ finished = TX_FALSE; /* Initialize the rebalance flag to false. */ rebalance = TX_FALSE; /* Lockout interrupts while thread attempts to relinquish control. */ TX_DISABLE /* Pickup the index. */ core_index = TX_SMP_CORE_ID; /* Pickup the current thread pointer. */ thread_ptr = _tx_thread_current_ptr[core_index]; #ifndef TX_NO_TIMER /* Reset time slice for current thread. */ _tx_timer_time_slice[core_index] = thread_ptr -> tx_thread_new_time_slice; #endif #ifdef TX_ENABLE_STACK_CHECKING /* Check this thread's stack. */ TX_THREAD_STACK_CHECK(thread_ptr) #endif /* If trace is enabled, insert this event into the trace buffer. */ TX_TRACE_IN_LINE_INSERT(TX_TRACE_THREAD_RELINQUISH, &thread_ptr, TX_POINTER_TO_ULONG_CONVERT(thread_ptr -> tx_thread_ready_next), 0, 0, TX_TRACE_THREAD_EVENTS) /* Log this kernel call. */ TX_EL_THREAD_RELINQUISH_INSERT /* Pickup the thread's priority. */ priority = thread_ptr -> tx_thread_priority; #ifdef TX_THREAD_SMP_DEBUG_ENABLE /* Debug entry. */ _tx_thread_smp_debug_entry_insert(0, 0, thread_ptr); #endif /* Pickup the next thread. */ next_thread = thread_ptr -> tx_thread_ready_next; /* Pickup the head of the list. */ head_ptr = _tx_thread_priority_list[priority]; /* Pickup the list tail. */ tail_ptr = head_ptr -> tx_thread_ready_previous; /* Determine if this thread is not the tail pointer. */ if (thread_ptr != tail_ptr) { /* Not the tail pointer, this thread must be moved to the end of the ready list. */ /* Determine if this thread is at the head of the list. */ if (head_ptr == thread_ptr) { /* Simply move the head pointer to put this thread at the end of the ready list at this priority. */ _tx_thread_priority_list[priority] = next_thread; } else { /* Now we need to remove this thread from its current position and place it at the end of the list. */ /* Pickup the previous thread pointer. */ previous_thread = thread_ptr -> tx_thread_ready_previous; /* Remove the thread from the ready list. */ next_thread -> tx_thread_ready_previous = previous_thread; previous_thread -> tx_thread_ready_next = next_thread; /* Insert the thread at the end of the list. */ tail_ptr -> tx_thread_ready_next = thread_ptr; head_ptr -> tx_thread_ready_previous = thread_ptr; thread_ptr -> tx_thread_ready_previous = tail_ptr; thread_ptr -> tx_thread_ready_next = head_ptr; } /* Pickup the mapped core of the relinquishing thread - this can be different from the current core. */ mapped_core = thread_ptr -> tx_thread_smp_core_mapped; /* Determine if the relinquishing thread is no longer present in the execute list. */ if (thread_ptr != _tx_thread_execute_ptr[mapped_core]) { /* Yes, the thread is no longer mapped. Set the rebalance flag to determine if there is a new mapping due to moving this thread to the end of the priority list. */ /* Set the rebalance flag to true. */ rebalance = TX_TRUE; } /* Determine if preemption-threshold is in force. */ else if (thread_ptr -> tx_thread_preempt_threshold == priority) { /* No preemption-threshold is in force. */ /* Determine if there is a thread at the same priority that isn't currently executing. */ do { /* Isolate the exclusion for this core. */ excluded = (next_thread -> tx_thread_smp_cores_excluded >> mapped_core) & ((ULONG) 1); /* Determine if the next thread has preemption-threshold set or is excluded from running on the mapped core. */ if ((next_thread -> tx_thread_preempt_threshold < next_thread -> tx_thread_priority) || (excluded == ((ULONG) 1))) { /* Set the rebalance flag. */ rebalance = TX_TRUE; /* Get out of the loop. We need to rebalance the list when we detect preemption-threshold. */ break; } else { /* Is the next thread already in the execute list? */ if (next_thread != _tx_thread_execute_ptr[next_thread -> tx_thread_smp_core_mapped]) { /* No, we can place this thread in the position the relinquishing thread was in. */ /* Remember this index in the thread control block. */ next_thread -> tx_thread_smp_core_mapped = mapped_core; /* Setup the entry in the execution list. */ _tx_thread_execute_ptr[mapped_core] = next_thread; #ifdef TX_THREAD_SMP_DEBUG_ENABLE /* Debug entry. */ _tx_thread_smp_debug_entry_insert(1, 0, next_thread); #endif #ifdef TX_THREAD_ENABLE_PERFORMANCE_INFO /* Increment the number of thread relinquishes. */ thread_ptr -> tx_thread_performance_relinquish_count++; /* Increment the total number of thread relinquish operations. */ _tx_thread_performance_relinquish_count++; /* No, there is another thread ready to run and will be scheduled upon return. */ _tx_thread_performance_non_idle_return_count++; #endif #ifdef TX_ENABLE_STACK_CHECKING /* Check this thread's stack. */ TX_THREAD_STACK_CHECK(next_thread) #endif #ifndef TX_NOT_INTERRUPTABLE /* Increment the preempt disable flag in order to keep the protection. */ _tx_thread_preempt_disable++; /* Restore interrupts. */ TX_RESTORE #endif /* Transfer control to the system so the scheduler can execute the next thread. */ _tx_thread_system_return(); #ifdef TX_NOT_INTERRUPTABLE /* Restore interrupts. */ TX_RESTORE #endif /* Set the finished flag. */ finished = TX_TRUE; } /* Move to the next thread at this priority. */ next_thread = next_thread -> tx_thread_ready_next; } } while ((next_thread != thread_ptr) && (finished == TX_FALSE)); /* Determine if we are finished. */ if (finished == TX_FALSE) { /* No other thread is ready at this priority... simply return. */ #ifdef TX_THREAD_SMP_DEBUG_ENABLE /* Debug entry. */ _tx_thread_smp_debug_entry_insert(1, 0, thread_ptr); #endif /* Restore interrupts. */ TX_RESTORE /* Set the finished flag. */ finished = TX_TRUE; } } else { /* Preemption-threshold is in force. */ /* Set the rebalance flag. */ rebalance = TX_TRUE; } } /* Determine if preemption-threshold is in force. */ if (thread_ptr -> tx_thread_preempt_threshold < priority) { /* Set the rebalance flag. */ rebalance = TX_TRUE; #ifndef TX_DISABLE_PREEMPTION_THRESHOLD #if TX_MAX_PRIORITIES > 32 /* Calculate the index into the bit map array. */ map_index = priority/((UINT) 32); #endif /* Ensure that this thread's priority is clear in the preempt map. */ TX_MOD32_BIT_SET(priority, priority_bit) _tx_thread_preempted_maps[MAP_INDEX] = _tx_thread_preempted_maps[MAP_INDEX] & (~(priority_bit)); #if TX_MAX_PRIORITIES > 32 /* Determine if there are any other bits set in this preempt map. */ if (_tx_thread_preempted_maps[MAP_INDEX] == ((ULONG) 0)) { /* No, clear the active bit to signify this preempted map has nothing set. */ TX_DIV32_BIT_SET(priority, priority_bit) _tx_thread_preempted_map_active = _tx_thread_preempted_map_active & (~(priority_bit)); } #endif /* Clear the entry in the preempted list. */ _tx_thread_preemption_threshold_list[priority] = TX_NULL; /* Does this thread have preemption-threshold? */ if (_tx_thread_preemption__threshold_scheduled == thread_ptr) { /* Yes, set the preempted thread to NULL. */ _tx_thread_preemption__threshold_scheduled = TX_NULL; } /* Calculate the first thread with preemption-threshold active. */ #if TX_MAX_PRIORITIES > 32 if (_tx_thread_preempted_map_active != ((ULONG) 0)) #else if (_tx_thread_preempted_maps[0] != ((ULONG) 0)) #endif { #if TX_MAX_PRIORITIES > 32 /* Calculate the index to find the next highest priority thread ready for execution. */ priority_map = _tx_thread_preempted_map_active; /* Calculate the lowest bit set in the priority map. */ TX_LOWEST_SET_BIT_CALCULATE(priority_map, map_index) /* Calculate the base priority as well. */ base_priority = map_index * ((UINT) 32); #else /* Setup the base priority to zero. */ base_priority = ((UINT) 0); #endif /* Setup temporary preempted map. */ priority_map = _tx_thread_preempted_maps[MAP_INDEX]; /* Calculate the lowest bit set in the priority map. */ TX_LOWEST_SET_BIT_CALCULATE(priority_map, priority_bit_set) /* Move priority bit set into priority bit. */ priority_bit = (ULONG) priority_bit_set; /* Setup the highest priority preempted thread. */ next_preempted = base_priority + priority_bit; /* Pickup the previously preempted thread. */ preempted_thread = _tx_thread_preemption_threshold_list[next_preempted]; /* Setup the preempted thread. */ _tx_thread_preemption__threshold_scheduled = preempted_thread; } #else /* Determine if this thread has preemption-threshold disabled. */ if (thread_ptr == _tx_thread_preemption__threshold_scheduled) { /* Clear the global preemption disable flag. */ _tx_thread_preemption__threshold_scheduled = TX_NULL; } #endif } /* Check to see if there is still work to do. */ if (finished == TX_FALSE) { #ifdef TX_THREAD_SMP_DEBUG_ENABLE /* Debug entry. */ _tx_thread_smp_debug_entry_insert(1, 0, thread_ptr); #endif /* Determine if we need to rebalance the execute list. */ if (rebalance == TX_TRUE) { /* Rebalance the excute list. */ _tx_thread_smp_rebalance_execute_list(core_index); } /* Determine if this thread needs to return to the system. */ if (_tx_thread_execute_ptr[core_index] != thread_ptr) { #ifdef TX_THREAD_ENABLE_PERFORMANCE_INFO /* Increment the number of thread relinquishes. */ thread_ptr -> tx_thread_performance_relinquish_count++; /* Increment the total number of thread relinquish operations. */ _tx_thread_performance_relinquish_count++; /* Determine if an idle system return is present. */ if (_tx_thread_execute_ptr[core_index] == TX_NULL) { /* Yes, increment the return to idle return count. */ _tx_thread_performance_idle_return_count++; } else { /* No, there is another thread ready to run and will be scheduled upon return. */ _tx_thread_performance_non_idle_return_count++; } #endif #ifdef TX_ENABLE_STACK_CHECKING /* Pickup new thread pointer. */ thread_ptr = _tx_thread_execute_ptr[core_index]; /* Check this thread's stack. */ TX_THREAD_STACK_CHECK(thread_ptr) #endif #ifndef TX_NOT_INTERRUPTABLE /* Increment the preempt disable flag in order to keep the protection. */ _tx_thread_preempt_disable++; /* Restore interrupts. */ TX_RESTORE #endif /* Transfer control to the system so the scheduler can execute the next thread. */ _tx_thread_system_return(); #ifdef TX_NOT_INTERRUPTABLE /* Restore interrupts. */ TX_RESTORE #endif } else { /* Restore interrupts. */ TX_RESTORE } } }