| Commit message (Collapse) | Author | Files | Lines |
|
Move implementation specific parts of rbtree.h and rbtree.inl into new
header file rbtreeimpl.h. The rbtree.h contains now only the
application visible API.
|
|
Move implementation specific parts of watchdog.h and watchdog.inl into
new header file watchdogimpl.h. The watchdog.h contains now only the
application visible API.
|
|
Move implementation specific parts of chain.h and chain.inl into new
header file chainimpl.h. The chain.h contains now only the application
visible API.
|
|
Move implementation specific parts of corespinlock.h and
corespinlock.inl into new header file corespinlockimpl.h. The
corespinlock.h contains now only the application visible API.
|
|
Pass the executing thread as a function parameter. Obtain the executing
thread inside a thread dispatch critical section to avoid problems on
SMP.
|
|
Move implementation specific parts of corerwlock.h and corerwlock.inl
into new header file corerwlockimpl.h. The corerwlock.h contains now
only the application visible API.
|
|
Pass the executing thread as a function parameter. Obtain the executing
thread inside a thread dispatch critical section to avoid problems on
SMP.
|
|
Move implementation specific parts of corebarrier.h and corebarrier.inl
into new header file corebarrierimpl.h. The corebarrier.h contains now
only the application visible API.
|
|
Pass the executing thread as a function parameter. Obtain the executing
thread inside a thread dispatch critical section to avoid problems on
SMP.
|
|
Move implementation specific parts of coremsg.h and coremsg.inl into new
header file coremsgimpl.h. The coremsg.h contains now only the
application visible API.
|
|
Pass the executing thread as a function parameter. Obtain the executing
thread inside a thread dispatch critical section to avoid problems on
SMP.
|
|
|
|
Move implementation specific parts of coresem.h and coresem.inl into new
header file coresemimpl.h. The coresem.h contains now only the
application visible API.
|
|
A common use case for disabled preemption was to ensure mutual exclusion
on single-processor configurations. On SMP this does not work.
To abandon non-preemptible tasks simplifies the scheduler.
|
|
|
|
|
|
Pass the executing thread as a function parameter. Obtain the executing
thread inside a thread dispatch critical section to avoid problems on
SMP.
|
|
Move implementation specific parts of coremutex.h and coremutex.inl into
new header file coremuteximpl.h. The coremutex.h contains now only the
application visible API.
|
|
|
|
Rename to _CPU_SMP_Processor_event_receive().
|
|
Rename to _CPU_SMP_Processor_event_broadcast().
|
|
Delete bsp_smp_interrupt_cpu().
|
|
Add and use _SMP_Get_current_processor() and
rtems_smp_get_current_processor().
Delete bsp_smp_interrupt_cpu().
Change type of current processor index from int to uint32_t to match
_SMP_Processor_count type.
|
|
The thread dispatch is a side-effect of interrupt processing, thus there
is no need to send an explicit message.
|
|
Delete _Thread_libc_reent and add __getreent() instead according to
__DYNAMIC_REENT__ define.
For SMP configurations __DYNAMIC_REENT__ must be defined.
A Newlib including the following patch is required:
2013-07-09 Sebastian Huber <sebastian.huber@embedded-brains.de>
* libc/include/sys/config.h (__DYNAMIC_REENT__): Define for RTEMS.
|
|
|
|
Add rtems_workspace_greedy_allocate_all_except_largest() and
rtems_heap_greedy_allocate_all_except_largest().
|
|
|
|
|
|
|
|
Add and use _Heap_Protection_free_all_delayed_blocks() to prevent
test suite failures if RTEMS_DEBUG is defined.
|
|
The new Simple SMP Scheduler allocates a processor for the processor
count highest priority ready threads. The thread priority and position
in the ready chain are the only information to determine the scheduling
decision. Threads with an allocated processor are in the scheduled
chain. After initialization the scheduled chain has exactly processor
count nodes. Each processor has exactly one allocated thread after
initialization. All enqueue and extract operations may exchange threads
with the scheduled chain. One thread will be added and another will be
removed. The scheduled and ready chain is ordered according to the
thread priority order. The chain insert operations are O(count of ready
threads), thus this scheduler is unsuitable for most real-time
applications.
The thread preempt mode will be ignored.
|
|
Add and use _Scheduler_simple_Insert_priority_fifo_order(),
_Scheduler_simple_Insert_priority_lifo_order(),
_Scheduler_simple_Insert_priority_fifo() and
_Scheduler_simple_Insert_priority_lifo().
|
|
Delete _Scheduler_priority_Tick(). Use _SMP_Get_processor_count() for
default tick operation. Delete _Scheduler_simple_smp_Tick().
|
|
The yielding thread of the yield operation is now specified by a
parameter. The tick operation may be performed for each executing
thread in a SMP configuration.
|
|
Add and use _Scheduler_Start_idle().
|
|
|
|
Rename in rtems_smp_get_processor_count(). Always provide
<rtems/score/smp.h> and <rtems/rtems/smp.h>. Add
_SMP_Get_processor_count(). This function will be a compile time
constant defined to be one on uni-processor configurations. This allows
iterations over all processors without overhead on uni-processor
configurations.
|
|
Delete _Thread_Dispatch_in_critical_section() and
_Thread_Is_dispatching_enabled().
|
|
We must obtain the processor ID after interrupts are disabled since a
non-optimizing compiler may store the value on the stack and read it
back.
|
|
|
|
Add and use _Per_CPU_Lock_release().
|
|
|
|
Add and use _Objects_Put_without_thread_dispatch(). These two functions
pair with the _Objects_Get() function. This helps to introduce object
specific SMP locks to avoid lock contention.
|
|
Provide SMP support. The ISR disable/enable is not enough to ensure
mutual exclusion for SMP configurations.
|
|
Align ISR disable/enable sequence in _Objects_Get_isr_disable() with
thread dispatch disable/enable sequence in _Objects_Get().
|
|
Move thread dispatch declarations and inline functions to new header
<rtems/score/threaddispatch.h> to make it independent of the
Thread_Control structure. This avoids a cyclic dependency in case
thread dispatch functions are used for the object implementation.
|
|
|
|
The _Thread_Initialize() function has nothing to do with thread
dispatching it simply initializes the thread control.
|
|
Move the SMP lock implementation to the CPU port. An optimal SMP lock
implementation is highly architecture dependent. For example the memory
models may be fundamentally different.
The new SMP lock API has a flaw. It does not provide the ability to use
a local context for acquire and release pairs. Such a context is
necessary to implement for example the Mellor-Crummey and Scott (MCS)
locks. The SMP lock is currently used in _Thread_Disable_dispatch() and
_Thread_Enable_dispatch() and makes them to a giant lock acquire and
release. Since these functions do not pass state information via a
local context there is currently no use case for such a feature.
|