| Commit message (Collapse) | Author | Files | Lines |
|
Several SMP message processing functions returned a value. This value
was always unused.
Close #4822.
|
|
Add SMP-specifc SMP_FATAL_MULTITASKING_START_ON_NOT_ONLINE_PROCESSOR
fatal error. This fatal error helps to diagnose a broken SMP startup
sequence. Without this error a context switch using the NULL pointer
for the thread control block happens which may be difficult to debug.
|
|
Disable thread dispatching earlier on secondary processors. This ensures that
fatal error and per-CPU job handlers are called with thread dispatching
disabled. On the boot processor, the thread dispatching is already disabled by
_Thread_Dispatch_initialization().
|
|
Updates #3053.
|
|
|
|
Use the processor control to specify the target processor since this is what
the callers have available.
|
|
|
|
Remove the unused _SMP_Send_message_multicast() and
_SMP_Send_message_broadcast().
|
|
The per-CPU states which control the SMP system initialization were added quite
early during the SMP support development. Replace this initial implementation
with a simplified one. There is no longer a global SMP lock required which
serialized the state changes of all processors. The new implementation better
integrates with the per-CPU jobs.
|
|
Make the initialization of the per-CPU data optional.
Change license to BSD-2-Clause according to file history and
re-licensing agreement.
Update #3053.
|
|
Use common phrases for the file brief descriptions.
Update #3706.
|
|
Use the following variant which was already used by most source files:
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
|
|
The work area initialization was done by the BSP through
bsp_work_area_initialize(). This approach predated the system
initialization through the system initialization linker set. The
workspace and C program heap were unconditionally initialized. The aim
is to support RTEMS application configurations which do not need the
workspace and C program heap. In these configurations, the workspace
and C prgram heap should not get initialized.
Change all bsp_work_area_initialize() to implement _Memory_Get()
instead. Move the dirty memory, sbrk(), per-CPU data, workspace, and
malloc() heap initialization into separate system initialization steps.
This makes it also easier to test the individual initialization steps.
This change adds a dependency to _Heap_Extend() to all BSPs. This
dependency will be removed in a follow up change.
Update #3838.
|
|
All uses were replaced by per-processor jobs.
|
|
Use _SMP_Multicast_action() instead.
|
|
Use a FIFO list of jobs per processor to carry out the SMP multicast
action. Use a done indicator per job to reduce the bus traffic a bit.
|
|
The use of a hand crafted lock for Per_CPU_Control::Lock was necessary
at some point in the SMP support development, but it is no longer
justified.
|
|
Add _ISR_lock_Set_name() to optimize the initialization of
zero-initialized locks.
|
|
Rename _SMP_Get_processor_count() in _SMP_Get_processor_maximum() to be
in line with the API level rtems_scheduler_get_processor_maximum().
Update #3732.
|
|
Rename _SMP_Processor_count in _SMP_Processor_maximum to be in line with
the API level rtems_scheduler_get_processor_maximum().
Update #3732.
|
|
Update #3706
|
|
Pass current processor control as first parameter to make dependency
more explicit.
|
|
Replace the simple processor count with the processor set owned by the
scheduler instance.
Update #3059.
|
|
Implement the Processor_mask via <sys/bitset.h>. Provide
_Processor_mask_To_uint32_t() to enable its use in device specific
routines, e.g. interrupt affinity register in an interrupt controller.
Update #3059.
|
|
|
|
Rename _Scheduler_Assignments into _Scheduler_Initial_assignments to
make it clear that they may not reflect the run-time scheduler
assignment.
Update #2797.
|
|
This makes it possible to adjust the scheduler of a processor at
run-time.
Update #2797.
|
|
Update #2556.
|
|
This enables fatal extensions to continue program execution after some
fatal errors.
|
|
According to the C11 standard only atomic read-modify-write operations
guarantee that the last value written in modification order is read, see
"7.17.3 Order and consistency". Thus we must use a read-modify-write in
_SMP_Inter_processor_interrupt_handler() to make sure we read an
up-to-date message.
|
|
Update #2555.
|
|
Use a red-black tree instead of delta chains.
Close #2344.
Update #2554.
Update #2555.
Close #2606.
|
|
Update #2554.
|
|
The use case for this is the Cortex-A9 MPCore which has per-processor
registers (only accessible by a particular processor) for the global
timer used by the clock driver. This might be useful for other drivers
as well.
Update #2554.
|
|
|
|
|
|
Rename Per_CPU_Control::started into Per_CPU_Control::online to match
standard nomenclature.
|
|
Delete SCORE_INIT. This finally removes the
some.h:
#ifndef SOME_XYZ_EXTERN
#define SOME_XYZ_EXTERN extern
#endif
SOME_XYZ_EXTERN type xyz;
some_xyz.c:
#define SOME_XYZ_EXTERN
#include <some.h>
pattern in favour of
some.h:
extern type xyz;
some_xyz.c
#include <some.h>
type xyz;
Update #2559.
|
|
The problem is that empty structures have a different size in C and C++.
|
|
|
|
|
|
Change message type to unsigned long to match other SMP message functions.
|
|
|
|
Do not use the Per_CPU_Control::started in
_SMP_Start_multitasking_on_secondary_processor() since this field may be
not up to date when a secondary processor reads it. Use the read-only
scheduler assignment instead.
Add a new fatal error SMP_FATAL_MULTITASKING_START_ON_INVALID_PROCESSOR.
This prevents out-of-bounds access.
It is currently not possible to test these fatal errors. One option
would be to fake values of the _CPU_SMP_Get_current_processor(), but
unfortunately this function is inline on some architectures.
|
|
|
|
|
|
The current implementation of task migration in RTEMS has some
implications with respect to the interrupt latency. It is crucial to
preserve the system invariant that a task can execute on at most one
processor in the system at a time. This is accomplished with a boolean
indicator in the task context. The processor architecture specific
low-level task context switch code will mark that a task context is no
longer executing and waits that the heir context stopped execution
before it restores the heir context and resumes execution of the heir
task. So there is one point in time in which a processor is without a
task. This is essential to avoid cyclic dependencies in case multiple
tasks migrate at once. Otherwise some supervising entity is necessary to
prevent life-locks. Such a global supervisor would lead to scalability
problems so this approach is not used. Currently the thread dispatch is
performed with interrupts disabled. So in case the heir task is
currently executing on another processor then this prolongs the time of
disabled interrupts since one processor has to wait for another
processor to make progress.
It is difficult to avoid this issue with the interrupt latency since
interrupts normally store the context of the interrupted task on its
stack. In case a task is marked as not executing we must not use its
task stack to store such an interrupt context. We cannot use the heir
stack before it stopped execution on another processor. So if we enable
interrupts during this transition we have to provide an alternative task
independent stack for this time frame. This issue needs further
investigation.
|
|
A default handler is not necessary. The test message sender must ensure
that a handler is installed.
|
|
|
|
This handler can be used to test the inter-processor interrupt
implementation.
|