kernel.h

ecos为实时嵌入式操作系统

 }

 cdl_option CYGNUM_KERNEL_THREADS_IDLE_STACK_SIZE {
     display            "Stack size for the idle thread"
     parent             CYGPKG_KERNEL_THREADS
     type               count
     legal_values       512 to 65536
     description "
         This configuration option specifies the stack size in bytes
         for the idle thread. Unless the HAL is configured to use a
         separate interrupt stack this size must be sufficient to meet
         the requirements of all interrupt handlers - these
         requirements are cumulative if nested interrupted are
         enabled. Depending on the target architecture, the stack size
         typically has to be a multiple of eight or sixteen bytes.
         This will be overridden where it is used if the
         architectural HAL requires a minimum stack size
         to handle interrupts correctly."
          
     doc ref/ecos-ref/thread-operations.html
 }

 }}CFG_DATA */

#define CYGFUN_KERNEL_THREADS_TIMER
#define CYGVAR_KERNEL_THREADS_NAME
#define CYGVAR_KERNEL_THREADS_LIST
#define CYGFUN_KERNEL_THREADS_STACK_LIMIT
#define CYGVAR_KERNEL_THREADS_DATA
#define CYGNUM_KERNEL_THREADS_DATA_MAX          6
#define CYGNUM_KERNEL_THREADS_IDLE_STACK_SIZE   2048


/* ---------------------------------------------------------------------
 * Synchronization primitives.

 {{CFG_DATA

 cdl_component CYGPKG_KERNEL_SYNCH {
     display    "Synchronization primitives"
     type       dummy
     parent     CYGPKG_KERNEL
     description "
         The eCos kernel supports a number of different
         synchronization primitives such as mutexes, semaphores,
         condition variables, and message boxes. There are
         configuration options to control the exact behaviour of some
         of these synchronization primitives.
     "
     doc ref/ecos-ref/thread-synchronization.html
 }

 # NOTE: the requires statement is only valid for the current kernel.
 # Priority inheritance is possible in other schedulers as well
 # but is not yet implemented.
 cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INHERITANCE_SIMPLE {
     display    "Simple mutex priority inheritance"
     requires   CYGSEM_KERNEL_SCHED_MLQUEUE
     parent     CYGPKG_KERNEL_SYNCH
     description "
         This option enables a relatively simple implementation of
         mutex priority inheritance. The implementation will only work
         in the mlqueue scheduler, and it does not handle the rare
         case of nested mutexes completely correctly. However it is
         both fast and deterministic. Mutex priority inheritance can
         be disabled if the application does not require it, which
         will reduce both code size and data space."
     doc ref/ecos-ref/synchronization.html#MUTEXES
 }

 cdl_option CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT {
     display    "Message box blocking put support"
     parent     CYGPKG_KERNEL_SYNCH
     description "
         Message boxes can support three different versions of the
         put-message operation. The first is tryput(), which will fail
         if the message box is already full. The other two are the
         ordinary put() function which will block if the message box
         is full, and a timed put() operation which will block for
         upto a certain length of time if the message box is currently
         full. The blocking versions require extra memory in the
         message box data structure and extra code in the other
         message box functions, so they can be disabled if the
         application does not require them. If this option is enabled
         then the system will always provide the blocking put()
         function, and it will also provide the timed put() function
         if thread timers are enabled."
     doc ref/ecos-ref/message-boxes.html
 }

 cdl_option CYGNUM_KERNEL_SYNCH_MBOX_QUEUE_SIZE {
     display            "Message box queue size"
     parent             CYGPKG_KERNEL_SYNCH
     type               count
     legal_values       1 to 65535
     description "
         This configuration option controls the number of messages
         that can be queued in a message box before a non-blocking
         put() operation will fail or a blocking put() operation will
         block. The cost in memory is one pointer per message box for
         each possible message."
 }

 cdl_option CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT {
     display            "Condition variable timed-wait support"
     parent             CYGPKG_KERNEL_SYNCH
     requires           CYGFUN_KERNEL_THREADS_TIMER
     description "
         This option enables the condition variable timed wait
         facility."
     doc ref/ecos-ref/synchronization.html#CONDITION-VARIABLES
 }

 }}CFG_DATA
 
 */

#define CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INHERITANCE_SIMPLE
#define CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT
#define CYGNUM_KERNEL_SYNCH_MBOX_QUEUE_SIZE     10
#define CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT

/* ---------------------------------------------------------------------
 {{CFG_DATA

 cdl_component CYGPKG_KERNEL_INSTRUMENT {
     display "Kernel instrumentation"
     parent  CYGPKG_KERNEL
     description "
         The current release of the kernel contains an initial version
         of instrumentation support. The various parts of the kernel
         will invoke instrumentation routines whenever appropriate
         events occur, and these will be stored in a circular buffer
         for later reference."
 }


 cdl_option CYGNUM_KERNEL_INSTRUMENT_BUFFER_SIZE {
     display            "Size of instrumentation buffer size"
     parent             CYGPKG_KERNEL_INSTRUMENT
     type               count
     legal_values       16 to 0x100000
     description "
         If kernel instrumentation is enabled then the instrumentation
         data goes into a circular buffer. A larger buffer allows
         more data to be stored, but at a significant cost in memory.
         The value of this option corresponds to the number of entries
         in the table, and typically each entry will require 16 bytes
         of memory."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_FLAGS {
     display            "Perform selective instrumentation"
     parent             CYGPKG_KERNEL_INSTRUMENT
     description "
         The kernel can either collect all instrumentation events, or
         it can filter out events at runtime based on a set of flags.
         For example it would be possible to decide at runtime that
         only scheduler and interrupt instrumentation flags are of
         interest and that all other flags should be ignored. This
         flag mechanism involves extra code and processor cycle
         overhead in the instrumentation code, so it can be disabled
         if the application developer is interested in all
         instrumentation events."
 }

 # NOTE: many of these options should only be active if the appropriate
 # component is active.
 cdl_option CYGDBG_KERNEL_INSTRUMENT_SCHED {
     display    "Instrument the scheduler"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not instrumentation support is compiled into
         the scheduling code."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_THREAD {
     display    "Instrument thread operations"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not instrumentation support is compiled into
         the code that manipulates threads."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_INTR {
     display    "Instrument interrupts"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not instrumentation support is compiled into
         the interrupt handling code."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_MUTEX {
     display    "Instrument mutex operations"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not instrumentation support is compiled into
         the mutex code."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_CONDVAR {
     display    "Instrument condition variable operations"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not instrumentation support is compiled into
         the condition variable code."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_BINSEM {
     display    "Instrument binary semaphore operations"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not instrumentation support is compiled into
         the binary semaphore code."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_CNTSEM {
     display    "Instrument counting semaphore operations"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not instrumentation support is compiled into
         the counting semaphore code."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_MBOXT {
     display    "Instrument message box operations"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not instrumentation support is compiled into
         the message box code."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_CLOCK {
     display    "Instrument clock operations"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not instrumentation support is compiled into
         the real-time clock code."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_ALARM {
     display    "Instrument alarm-related operations"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not instrumentation support is compiled into
         the code related to alarm operations."
 }

 cdl_option CYGDBG_KERNEL_INSTRUMENT_USER {
     display    "Support application-level instrumentation"
     parent     CYGPKG_KERNEL_INSTRUMENT
     description "
         It is possible to perform selective instrumentation at
         run-time. It is also possible to disable instrumentation
         in various kernel components at compile-time, thus
         reducing the code size overheads. This option controls
         whether or not application-level instrumentation gets
         compiled in."
 }
 
 }}CFG_DATA
*/

#undef  CYGPKG_KERNEL_INSTRUMENT
#undef  CYGVAR_KERNEL_INSTRUMENT_EXTERNAL_BUFFER
#define CYGNUM_KERNEL_INSTRUMENT_BUFFER_SIZE           256
#define CYGDBG_KERNEL_INSTRUMENT_FLAGS
#define CYGDBG_KERNEL_INSTRUMENT_SCHED
#define CYGDBG_KERNEL_INSTRUMENT_THREAD
#define CYGDBG_KERNEL_INSTRUMENT_INTR
#define CYGDBG_KERNEL_INSTRUMENT_MUTEX
#define CYGDBG_KERNEL_INSTRUMENT_CONDVAR
#define CYGDBG_KERNEL_INSTRUMENT_BINSEM
#define CYGDBG_KERNEL_INSTRUMENT_CNTSEM
#define CYGDBG_KERNEL_INSTRUMENT_CLOCK
#define CYGDBG_KERNEL_INSTRUMENT_ALARM
#define CYGDBG_KERNEL_INSTRUMENT_MBOXT
#define CYGDBG_KERNEL_INSTRUMENT_USER

/* ---------------------------------------------------------------------
 * There appears to be somewhat of a lack of configuration options here.