Changeset 45ee958 in rtems


Ignore:
Timestamp:
09/30/22 06:06:18 (8 months ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
master
Children:
64fbeaa
Parents:
6a820853
git-author:
Sebastian Huber <sebastian.huber@…> (09/30/22 06:06:18)
git-committer:
Sebastian Huber <sebastian.huber@…> (10/14/22 08:48:23)
Message:

config: Add CONFIGURE_IDLE_TASK_STORAGE_SIZE

By default, allocate the IDLE task storage areas from the RTEMS Workspace.
This avoids having to estimate the thread-local storage size in the default
configuration.

Add the application configuration option CONFIGURE_IDLE_TASK_STORAGE_SIZE to
request a static allocation of the task storage area for IDLE tasks.

Update #3835.
Update #4524.

Files:
4 added
22 edited

Legend:

Unmodified
Added
Removed

  • cpukit/doxygen/appl-config.h

    r6a820853 r45ee958  
    34323432#define CONFIGURE_IDLE_TASK_STACK_SIZE
    34333433
     3434/* Generated from spec:/acfg/if/idle-task-storage-size */
     3435
     3436/**
     3437 * @brief This configuration option is an integer define.
     3438 *
     3439 * If this configuration option is specified, then the task storage areas for
     3440 * the IDLE tasks are statically allocated by <rtems/confdefs.h>.  The value of
     3441 * this configuration option defines the size in bytes of the task storage area
     3442 * of each IDLE task in the system.
     3443 *
     3444 * @par Default Value
     3445 * This configuration option has no default value.  If it is not specified,
     3446 * then the task storage area for each IDLE task will allocated from the RTEMS
     3447 * Workspace or through a custom IDLE task stack allocator.
     3448 *
     3449 * @par Constraints
     3450 * The value of the configuration option shall be greater than or equal to
     3451 * #CONFIGURE_IDLE_TASK_STACK_SIZE.
     3452 *
     3453 * @par Notes
     3454 * @parblock
     3455 * By default, the IDLE task storage areas are allocated from the RTEMS
     3456 * Workspace.  Applications which do not want to use a heap allocator can use
     3457 * this configuration option to use statically allocated memory for the IDLE
     3458 * task storage areas.  The task storage area contains the task stack, the
     3459 * thread-local storage, and the floating-point context on architectures with a
     3460 * separate floating-point context.  The size of the thread-local storage area
     3461 * is defined at link time or by the
     3462 * #CONFIGURE_MAXIMUM_THREAD_LOCAL_STORAGE_SIZE configuration option.  You have
     3463 * to estimate the actual thread-local storage size if you want to use this
     3464 * configuration option.  If the IDLE task stack size would be less than the
     3465 * value defined by the #CONFIGURE_IDLE_TASK_STACK_SIZE configuration option,
     3466 * for example because the thread-local storage size is larger than expected,
     3467 * then the system terminates with the INTERNAL_ERROR_CORE fatal source and the
     3468 * INTERNAL_ERROR_IDLE_THREAD_STACK_TOO_SMALL fatal code during system
     3469 * initialization.
     3470 *
     3471 * The value of this configuration option is passed to
     3472 * RTEMS_TASK_STORAGE_SIZE() by <rtems/confdefs.h> to determine the actual size
     3473 * of the statically allocated area to take architecture-specific overheads
     3474 * into account.
     3475 *
     3476 * The
     3477 *
     3478 * * ``CONFIGURE_IDLE_TASK_STORAGE_SIZE``, and
     3479 *
     3480 * * #CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE
     3481 *
     3482 * configuration options are mutually exclusive.
     3483 * @endparblock
     3484 */
     3485#define CONFIGURE_IDLE_TASK_STORAGE_SIZE
     3486
    34343487/** @} */
    34353488
    … …  
    48274880 *
    48284881 * The value of this configuration option is the address for the stack
    4829  * allocator allocate handler used to allocate the task stack of each IDLE
    4830  * task.
    4831  *
    4832  * @par Default Value
    4833  * The default value is ``_Stack_Allocator_allocate_for_idle_default``, which
    4834  * indicates that IDLE task stacks will be allocated from an area statically
    4835  * allocated by ``<rtems/confdefs.h>``.
    4836  *
    4837  * @par Value Constraints
    4838  * The value of this configuration option shall be defined to a valid function
    4839  * pointer of the type ``void *( *allocate )( uint32_t, size_t * )``.
    4840  *
    4841  * @par Notes
     4882 * allocator allocate handler used to allocate the task storage area of each
     4883 * IDLE task.
     4884 *
     4885 * @par Default Value
     4886 * By default, the IDLE task storage area will be allocated from the RTEMS
     4887 * Workspace.
     4888 *
     4889 * @par Value Constraints
     4890 * @parblock
     4891 * The following constraints apply to this configuration option:
     4892 *
     4893 * * The value of the configuration option shall be defined to a valid function
     4894 *   pointer of the type ``void *( *allocate )( uint32_t, size_t * )``.
     4895 *
     4896 * * The IDLE task stack allocator shall return a pointer to the allocated
     4897 *   memory area or terminate the system with a fatal error if the allocation
     4898 *   request cannot be satisfied.
     4899 *
     4900 * * The IDLE task stack allocator may increase the size of the allocated
     4901 *   memory area.
     4902 * @endparblock
     4903 *
     4904 * @par Notes
     4905 * @parblock
    48424906 * This configuration option is independent of the other thread stack allocator
    4843  * configuration options.  It is assumed that any memory allocated for the
    4844  * stack of an IDLE task will not be from the RTEMS Workspace or the memory
    4845  * statically allocated by default.
     4907 * configuration options.  It is assumed that any memory allocated for the task
     4908 * storage area of an IDLE task will not be from the RTEMS Workspace.
     4909 *
     4910 * The IDLE task stack allocator may increase the size of the allocated memory
     4911 * area to account for the actually allocated memory area.
     4912 *
     4913 * The
     4914 *
     4915 * * #CONFIGURE_IDLE_TASK_STORAGE_SIZE, and
     4916 *
     4917 * * ``CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE``
     4918 *
     4919 * configuration options are mutually exclusive.
     4920 * @endparblock
    48464921 */
    48474922#define CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE

  • cpukit/include/rtems/confdefs/percpu.h

    r6a820853 r45ee958  
    137137const size_t _Thread_Idle_stack_size = CONFIGURE_IDLE_TASK_STACK_SIZE;
    138138
    139 /*
    140  * If the user provides a custom idle stack allocator, then we do not need
    141  * memory reserved for the stacks but the symbol is still referenced in
    142  * threadcreateidle.c. The code path just never uses it. Make it minimal
    143  * size to proceed.
    144  */
    145 #ifndef CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE
    146   char _Thread_Idle_stacks[
    147     _CONFIGURE_MAXIMUM_PROCESSORS
    148       * ( CONFIGURE_IDLE_TASK_STACK_SIZE + CPU_IDLE_TASK_IS_FP * CONTEXT_FP_SIZE )
    149   ] RTEMS_ALIGNED( CPU_INTERRUPT_STACK_ALIGNMENT )
    150   RTEMS_SECTION( ".rtemsstack.idle" );
    151 #endif
    152 
    153139#if defined(CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION) && \
    154140  !defined(CONFIGURE_IDLE_TASK_BODY)

  • cpukit/include/rtems/confdefs/threads.h

    r6a820853 r45ee958  
    236236
    237237const size_t _Thread_Initial_thread_count =
     238#if !defined(CONFIGURE_IDLE_TASK_STORAGE_SIZE) && \
     239  !defined(CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE)
     240  _CONFIGURE_MAXIMUM_PROCESSORS +
     241#endif
    238242  rtems_resource_maximum_per_allocation( _CONFIGURE_TASKS ) +
    239243  rtems_resource_maximum_per_allocation( CONFIGURE_MAXIMUM_POSIX_THREADS );

  • cpukit/include/rtems/confdefs/wkspace.h

    r6a820853 r45ee958  
    4848#include <rtems/confdefs/initthread.h>
    4949#include <rtems/confdefs/objectsposix.h>
     50#include <rtems/confdefs/percpu.h>
    5051#include <rtems/confdefs/threads.h>
    5152#include <rtems/confdefs/wkspacesupport.h>
    … …  
    112113    + _CONFIGURE_HEAP_HANDLER_OVERHEAD )
    113114
     115#if defined(CONFIGURE_IDLE_TASK_STORAGE_SIZE) || \
     116  defined(CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE)
     117  #define _CONFIGURE_IDLE_TASK_STACKS 0
     118#else
     119  #define _CONFIGURE_IDLE_TASK_STACKS \
     120    ( _CONFIGURE_MAXIMUM_PROCESSORS * \
     121      _Configure_From_stackspace( CONFIGURE_IDLE_TASK_STACK_SIZE ) )
     122#endif
     123
    114124#define _CONFIGURE_STACK_SPACE_SIZE \
    115125  ( _CONFIGURE_INIT_TASK_STACK_EXTRA \
     126    + _CONFIGURE_IDLE_TASK_STACKS \
    116127    + _CONFIGURE_POSIX_INIT_THREAD_STACK_EXTRA \
    117128    + _CONFIGURE_LIBBLOCK_TASKS_STACK_EXTRA \
    … …  
    213224#endif
    214225
    215 /*
    216  * Custom IDLE thread stacks allocator. If this is provided, it is assumed
    217  * that the allocator is providing its own memory for these stacks.
    218  */
    219 #ifdef CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE
    220   const Stack_Allocator_allocate_for_idle _Stack_Allocator_allocate_for_idle =
    221     CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE;
    222 #endif
     226#ifdef CONFIGURE_IDLE_TASK_STORAGE_SIZE
     227  #ifdef CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE
     228    #error "CONFIGURE_IDLE_TASK_STORAGE_SIZE and CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE are mutually exclusive"
     229  #endif
     230
     231  #define _CONFIGURE_IDLE_TASK_STORAGE_SIZE \
     232    RTEMS_ALIGN_UP( \
     233      RTEMS_TASK_STORAGE_SIZE( \
     234        CONFIGURE_IDLE_TASK_STORAGE_SIZE, \
     235        RTEMS_DEFAULT_ATTRIBUTES \
     236      ), \
     237      CPU_INTERRUPT_STACK_ALIGNMENT \
     238    )
     239
     240  const size_t _Stack_Allocator_allocate_for_idle_storage_size =
     241    _CONFIGURE_IDLE_TASK_STORAGE_SIZE;
     242
     243  char _Stack_Allocator_allocate_for_idle_storage_areas[
     244    _CONFIGURE_MAXIMUM_PROCESSORS * _CONFIGURE_IDLE_TASK_STORAGE_SIZE
     245  ] RTEMS_ALIGNED( CPU_INTERRUPT_STACK_ALIGNMENT )
     246  RTEMS_SECTION( ".rtemsstack.idle" );
     247
     248  #define CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE \
     249    _Stack_Allocator_allocate_for_idle_static
     250#endif
     251
     252#ifndef CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE
     253  #define CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE \
     254    _Stack_Allocator_allocate_for_idle_workspace
     255#endif
     256
     257const Stack_Allocator_allocate_for_idle _Stack_Allocator_allocate_for_idle =
     258  CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE;
    223259
    224260#ifdef CONFIGURE_DIRTY_MEMORY

  • cpukit/include/rtems/score/interr.h

    r6a820853 r45ee958  
    230230  INTERNAL_ERROR_TOO_LARGE_TLS_SIZE = 41,
    231231  INTERNAL_ERROR_RTEMS_INIT_TASK_CONSTRUCT_FAILED = 42,
    232   INTERNAL_ERROR_IDLE_THREAD_CREATE_FAILED = 43
     232  INTERNAL_ERROR_IDLE_THREAD_CREATE_FAILED = 43,
     233  INTERNAL_ERROR_NO_MEMORY_FOR_IDLE_TASK_STORAGE = 44
    233234} Internal_errors_Core_list;
    234235

  • cpukit/include/rtems/score/stack.h

    r6a820853 r45ee958  
    1212
    1313/*
    14  *  COPYRIGHT (c) 1989-2006.
    15  *  On-Line Applications Research Corporation (OAR).
     14 * Copyright (C) 2022 embedded brains GmbH
     15 * Copyright (C) 1989, 2021 On-Line Applications Research Corporation (OAR)
    1616 *
    1717 * Redistribution and use in source and binary forms, with or without
    … …  
    173173void _Stack_Allocator_do_initialize( void );
    174174
    175 /** @} */
     175/**
     176 * @brief Allocates the IDLE thread storage area from the workspace.
     177 *
     178 * If the thread storage area cannot be allocated, then the
     179 * ::INTERNAL_ERROR_NO_MEMORY_FOR_IDLE_TASK_STACK fatal error will occur.
     180 *
     181 * @param unused is an unused parameter.
     182 *
     183 * @param stack_size[in] is pointer to a size_t object.  On function entry, the
     184 *   object contains the size of the task storage area to allocate in bytes.
     185 *
     186 * @return Returns a pointer to the begin of the allocated task storage area.
     187 */
     188void *_Stack_Allocator_allocate_for_idle_workspace(
     189  uint32_t  unused,
     190  size_t   *storage_size
     191);
     192
     193/**
     194 * @brief The size in bytes of the idle thread storage area used by
     195 *   _Stack_Allocator_allocate_for_idle_static().
     196 *
     197 * Application provided via <rtems/confdefs.h>.
     198 */
     199extern const size_t _Stack_Allocator_allocate_for_idle_storage_size;
     200
     201/**
     202 * @brief The thread storage areas used by
     203 *   _Stack_Allocator_allocate_for_idle_static().
     204 *
     205 * Application provided via <rtems/confdefs.h>.
     206 */
     207extern char _Stack_Allocator_allocate_for_idle_storage_areas[];
     208
     209/**
     210 * @brief Allocates the IDLE thread storage from the memory statically
     211 *   allocated by <rtems/confdefs.h>.
     212 *
     213 * @param cpu_index is the index of the CPU for the IDLE thread using this stack.
     214 *
     215 * @param stack_size[out] is pointer to a size_t object.  On function return, the
     216 *   object value is set to the value of
     217 *   ::_Stack_Allocator_allocate_for_idle_storage_size.
     218 *
     219 * @return Returns a pointer to the begin of the allocated task storage area.
     220 */
     221void *_Stack_Allocator_allocate_for_idle_static(
     222  uint32_t  cpu_index,
     223  size_t   *storage_size
     224);
     225
    176226/**
    177227 * @brief The stack allocator allocate stack for idle thread handler.
    … …  
    181231extern const Stack_Allocator_allocate_for_idle
    182232  _Stack_Allocator_allocate_for_idle;
     233
     234/** @} */
    183235
    184236#ifdef __cplusplus

  • cpukit/include/rtems/score/thread.h

    r6a820853 r45ee958  
    11871187}
    11881188
    1189 /**
    1190  * @brief The idle thread stacks.
    1191  *
    1192  * Provided by the application via <rtems/confdefs.h>.
    1193  */
    1194 extern char _Thread_Idle_stacks[];
    1195 
    11961189#if defined(RTEMS_MULTIPROCESSING)
    11971190/**

  • cpukit/sapi/src/interrtext.c

    r6a820853 r45ee958  
    8585  "INTERNAL_ERROR_TOO_LARGE_TLS_SIZE",
    8686  "INTERNAL_ERROR_RTEMS_INIT_TASK_CONSTRUCT_FAILED",
    87   "INTERNAL_ERROR_IDLE_THREAD_CREATE_FAILED"
     87  "INTERNAL_ERROR_IDLE_THREAD_CREATE_FAILED",
     88  "INTERNAL_ERROR_NO_MEMORY_FOR_IDLE_TASK_STORAGE"
    8889};
    8990

  • cpukit/score/src/stackallocatorforidle.c

    r6a820853 r45ee958  
     1/* SPDX-License-Identifier: BSD-2-Clause */
     2
     3/**
     4 * @file
     5 *
     6 * @ingroup RTEMSScoreStack
     7 *
     8 * @brief This source file contains the implementation of
     9 *   _Stack_Allocator_allocate_for_idle_static().
     10 */
     11
    112/*
    2  * SPDX-License-Identifier: BSD-2-Clause
    3  *
    413 * Copyright (C) 2021 On-Line Applications Research Corporation (OAR)
    514 *
    … …  
    3140
    3241#include <rtems/score/stack.h>
    33 #include <rtems/score/thread.h>
    3442#include <rtems/score/assert.h>
    3543
    36 /**
    37  * @brief Default stack allocator allocate for IDLE threads.
    38  *
    39  * The default allocator for IDLE thread stacks gets the memory from a
    40  * statically allocated area provided via confdefs.h.
    41  *
    42  * @param cpu is the index of the CPU for the IDLE thread using this stack.
    43  *
    44  * @param stack_size[in] is pointer to a size_t object.  On function
    45  *   entry, the object contains the size of the stack area to allocate in
    46  *   bytes.
    47  *
    48  * @return Returns the pointer to begin of the allocated stack area.
    49  */
    50 static void *_Stack_Allocator_allocate_for_idle_default(
     44void *_Stack_Allocator_allocate_for_idle_static(
    5145  uint32_t  cpu_index,
    52   size_t   *stack_size
     46  size_t   *storage_size
    5347)
    5448{
     49  size_t size;
     50
     51  size = _Stack_Allocator_allocate_for_idle_storage_size;
     52  *storage_size = size;
    5553#if defined(RTEMS_SMP)
    56   return &_Thread_Idle_stacks[ cpu_index * ( *stack_size ) ];
     54  return &_Stack_Allocator_allocate_for_idle_storage_areas[ cpu_index * size ];
    5755#else
    5856  _Assert( cpu_index == 0 );
    59   return &_Thread_Idle_stacks[ 0 ];
     57  return &_Stack_Allocator_allocate_for_idle_storage_areas[ 0 ];
    6058#endif
    6159}
    62 
    63 const Stack_Allocator_allocate_for_idle _Stack_Allocator_allocate_for_idle =
    64         _Stack_Allocator_allocate_for_idle_default;

  • cpukit/score/src/threadcreateidle.c

    r6a820853 r45ee958  
    5454#include <string.h>
    5555
    56 static void _Thread_Create_idle_for_CPU( Per_CPU_Control *cpu )
     56static void _Thread_Create_idle_for_CPU(
     57  Per_CPU_Control *cpu,
     58  uintptr_t        storage_size
     59)
    5760{
    5861  Thread_Configuration  config;
    … …  
    7174  config.is_preemptible = true;
    7275  config.stack_free = _Objects_Free_nothing;
    73   config.stack_size = _Thread_Idle_stack_size
    74     + CPU_IDLE_TASK_IS_FP * CONTEXT_FP_SIZE;
     76  config.stack_size = storage_size;
    7577
    7678  /*
    … …  
    119121void _Thread_Create_idle( void )
    120122{
     123  uintptr_t storage_size;
    121124#if defined(RTEMS_SMP)
    122   uint32_t cpu_max;
    123   uint32_t cpu_index;
     125  uint32_t  cpu_max;
     126  uint32_t  cpu_index;
     127#endif
    124128
     129  storage_size = _TLS_Get_allocation_size() +
     130    CPU_IDLE_TASK_IS_FP * CONTEXT_FP_SIZE +
     131    _Thread_Idle_stack_size;
     132
     133#if defined(RTEMS_SMP)
    125134  cpu_max = _SMP_Get_processor_maximum();
    126135
    … …  
    129138
    130139    if ( _Per_CPU_Is_processor_online( cpu ) ) {
    131       _Thread_Create_idle_for_CPU( cpu );
     140      _Thread_Create_idle_for_CPU( cpu, storage_size );
    132141    }
    133142  }
    134143#else
    135   _Thread_Create_idle_for_CPU( _Per_CPU_Get() );
     144  _Thread_Create_idle_for_CPU( _Per_CPU_Get(), storage_size );
    136145#endif
    137146

  • spec/build/cpukit/librtemscpu.yml

    r6a820853 r45ee958  
    15461546- cpukit/score/src/stackallocator.c
    15471547- cpukit/score/src/stackallocatorforidle.c
     1548- cpukit/score/src/stackallocatorforidlewkspace.c
    15481549- cpukit/score/src/stackallocatorfree.c
    15491550- cpukit/score/src/stackallocatorinit.c

  • spec/build/testsuites/sptests/grp.yml

    r6a820853 r45ee958  
    260260  uid: spfatal35
    261261- role: build-dependency
     262  uid: spfatal36
     263- role: build-dependency
    262264  uid: spfifo01
    263265- role: build-dependency

  • testsuites/sptests/spinternalerror02/init.c

    r6a820853 r45ee958  
    5050
    5151  rtems_test_assert(
    52     error - 3 == INTERNAL_ERROR_IDLE_THREAD_CREATE_FAILED
     52    error - 3 == INTERNAL_ERROR_NO_MEMORY_FOR_IDLE_TASK_STORAGE
    5353  );
    5454}

  • testsuites/sptests/spstkalloc02/init.c

    r6a820853 r45ee958  
    4545#include <inttypes.h>
    4646
     47#include <rtems/malloc.h>
    4748#include <rtems/score/heapimpl.h>
    4849
    … …  
    5657
    5758static void *task_stack_allocate(size_t stack_size);
     59
     60static void *task_stack_allocate_for_idle(uint32_t unused, size_t *stack_size);
    5861
    5962static void task_stack_free(void *addr);
    … …  
    150153#define CONFIGURE_TASK_STACK_ALLOCATOR_INIT task_stack_init
    151154#define CONFIGURE_TASK_STACK_ALLOCATOR task_stack_allocate
     155#define CONFIGURE_TASK_STACK_ALLOCATOR_FOR_IDLE task_stack_allocate_for_idle
    152156#define CONFIGURE_TASK_STACK_DEALLOCATOR task_stack_free
    153157#define CONFIGURE_TASK_STACK_ALLOCATOR_AVOIDS_WORK_SPACE
    … …  
    184188}
    185189
     190static void *task_stack_allocate_for_idle(uint32_t unused, size_t *stack_size)
     191{
     192  return rtems_heap_allocate_aligned_with_boundary(
     193    *stack_size,
     194    CPU_STACK_ALIGNMENT,
     195    0
     196  );
     197}
     198
    186199static void task_stack_free(void *addr)
    187200{

  • testsuites/sptests/sptls02/init.cc

    r6a820853 r45ee958  
    4949static thread_local long i0;
    5050
    51 alignas(512) static thread_local long a512;
     51alignas(RTEMS_MINIMUM_STACK_SIZE) static thread_local long a;
    5252
    5353int seven()
    … …  
    6262        a256 = 0xdead0002;
    6363        i0 = 0xdead0003;
    64         a512 = 0xdead0004;
     64        a = 0xdead0004;
    6565}
    6666
    … …  
    174174        rtems_test_assert((addr % 256) == 0);
    175175        rtems_test_assert(i0 == 0);
    176         rtems_test_assert(a512 == 0);
    177         addr = reinterpret_cast<uintptr_t>(&a512);
     176        rtems_test_assert(a == 0);
     177        addr = reinterpret_cast<uintptr_t>(&a);
    178178        RTEMS_OBFUSCATE_VARIABLE(addr);
    179179        rtems_test_assert((addr % 512) == 0);

  • testsuites/validation/ts-default.h

    r6a820853 r45ee958  
    318318
    319319static char test_idle_stacks[ CONFIGURE_MAXIMUM_PROCESSORS ][
    320   ( TEST_IDLE_STACK_SIZE + CPU_IDLE_TASK_IS_FP * CONTEXT_FP_SIZE )
     320  RTEMS_ALIGN_UP(
     321    MAX_TLS_SIZE + TEST_IDLE_STACK_SIZE + CPU_IDLE_TASK_IS_FP * CONTEXT_FP_SIZE,
     322    CPU_INTERRUPT_STACK_ALIGNMENT
     323  )
    321324]
    322325RTEMS_ALIGNED( CPU_INTERRUPT_STACK_ALIGNMENT )

  • testsuites/validation/ts-fatal-sysinit.h

    r6a820853 r45ee958  
    134134  { .fatal = TestSuiteFatalExtension }
    135135
     136#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE
     137
    136138#if !defined(CONFIGURE_RTEMS_INIT_TASKS_TABLE)
    137139

  • testsuites/validation/ts-idle.h

    r6a820853 r45ee958  
    7373  { .fatal = FatalInitialExtension }
    7474
     75#ifndef CONFIGURE_IDLE_TASK_STORAGE_SIZE
     76#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE
     77#endif
     78
    7579#define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION
    7680

  • testsuites/validation/ts-validation-acfg-0.c

    r6a820853 r45ee958  
    7373const char rtems_test_name[] = "ValidationAcfg0";
    7474
     75#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE
     76
    7577#define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION
    7678

  • testsuites/validation/ts-validation-acfg-1.c

    r6a820853 r45ee958  
    9595#define CONFIGURE_DISABLE_BSP_SETTINGS
    9696
     97#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE
     98
    9799#define CONFIGURE_MAXIMUM_TASKS 1
    98100

  • testsuites/validation/ts-validation-io-kernel.c

    r6a820853 r45ee958  
    139139#define CONFIGURE_SCHEDULER_TABLE_ENTRIES { }
    140140
     141#define CONFIGURE_IDLE_TASK_STORAGE_SIZE RTEMS_MINIMUM_STACK_SIZE
     142
    141143#define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION
    142144

  • testsuites/validation/ts-validation-tls-1.c

    r6a820853 r45ee958  
    6969const char rtems_test_name[] = "ValidationTls1";
    7070
     71#define CONFIGURE_IDLE_TASK_STORAGE_SIZE \
     72  ( RTEMS_MINIMUM_STACK_SIZE + 4096 )
     73
    7174#include "ts-idle.h"
    7275
Note: See TracChangeset for help on using the changeset viewer.