OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/trunk/rtos/ecos-2.0/packages/kernel/v2_0/cdl
    from Rev 27 to Rev 174
    ↔ Reverse comparison
  •

Rev 27 → Rev 174

/scheduler.cdl
0,0 → 1,256
# ====================================================================
#
# scheduler.cdl
#
# configuration data related to the kernel schedulers
#
# ====================================================================
#####ECOSGPLCOPYRIGHTBEGIN####
## -------------------------------------------
## This file is part of eCos, the Embedded Configurable Operating System.
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
##
## eCos is free software; you can redistribute it and/or modify it under
## the terms of the GNU General Public License as published by the Free
## Software Foundation; either version 2 or (at your option) any later version.
##
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY
## WARRANTY; without even the implied warranty of MERCHANTABILITY or
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
## for more details.
##
## You should have received a copy of the GNU General Public License along
## with eCos; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
##
## As a special exception, if other files instantiate templates or use macros
## or inline functions from this file, or you compile this file and link it
## with other works to produce a work based on this file, this file does not
## by itself cause the resulting work to be covered by the GNU General Public
## License. However the source code for this file must still be made available
## in accordance with section (3) of the GNU General Public License.
##
## This exception does not invalidate any other reasons why a work based on
## this file might be covered by the GNU General Public License.
##
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
## at http://sources.redhat.com/ecos/ecos-license/
## -------------------------------------------
#####ECOSGPLCOPYRIGHTEND####
# ====================================================================
######DESCRIPTIONBEGIN####
#
# Author(s): jskov
# Original data: nickg
# Contributors:
# Date: 1999-07-05
#
#####DESCRIPTIONEND####
#
# ====================================================================
 
cdl_interface CYGINT_KERNEL_SCHEDULER {
display "Number of schedulers in this configuration"
no_define
requires 1 == CYGINT_KERNEL_SCHEDULER
}
 
cdl_interface CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES {
display "Non-zero if the active schedule only has unique priorities"
description "
Not all schedulers allow mutiple threads to use the same
priority. That property is signalled via this option, allowing
scheduler and tests to behave accordingly."
}
 
# FIXME: The two below options must be mutually exclusive
cdl_component CYGSEM_KERNEL_SCHED_MLQUEUE {
display "Multi-level queue scheduler"
default_value 1
implements CYGINT_KERNEL_SCHEDULER
description "
The multi-level queue scheduler supports multiple priority
levels and multiple threads at each priority level.
Preemption between priority levels is automatic. Timeslicing
within a given priority level is controlled by a separate
configuration option."
 
cdl_option CYGDBG_KERNEL_TRACE_TIMESLICE {
display "Output timeslices when tracing"
active_if CYGDBG_USE_TRACING
requires !CYGDBG_INFRA_DEBUG_TRACE_ASSERT_SIMPLE
requires !CYGDBG_INFRA_DEBUG_TRACE_ASSERT_FANCY
default_value 0
description "
When tracing is enabled, output trace messages every
timeslice. This can be quite verbose so is disabled by
default."
}
}
 
cdl_option CYGSEM_KERNEL_SCHED_BITMAP {
display "Bitmap scheduler"
default_value 0
implements CYGINT_KERNEL_SCHEDULER
implements CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES
requires !CYGPKG_KERNEL_SMP_SUPPORT
description "
The bitmap scheduler supports multiple priority levels but
only one thread can exist at each priority level. This means
that scheduling decisions are very simple and hence the
scheduler is efficient. Preemption between priority levels is
automatic. Timeslicing within a given priority level is
irrelevant since there can be only one thread at each
priority level."
}
 
#cdl_option CYGSEM_KERNEL_SCHED_LOTTERY {
# display "Lottery scheduler"
# type radio
# description "
# This scheduler is not yet available."
#}
 
cdl_option CYGPRI_KERNEL_SCHED_IMPL_HXX {
display "Scheduler header file"
flavor data
description "
This option sets a preprocessor symbol which names the header
file for the selected scheduler. It is used internally by the
common scheduler code to include the correct header file."
calculated { \
CYGSEM_KERNEL_SCHED_BITMAP ? "<cyg/kernel/bitmap.hxx>" :\
CYGSEM_KERNEL_SCHED_MLQUEUE ? "<cyg/kernel/mlqueue.hxx>" :\
CYGSEM_KERNEL_SCHED_LOTTERY ? "<cyg/kernel/lottery.hxx>" :\
"!!!-- Configuration broken - no scheduler selected --!!!"}
}
 
 
 
# NOTE: This option only makes sense if the current scheduler
# supports multiple priority levels.
cdl_component CYGNUM_KERNEL_SCHED_PRIORITIES {
display "Number of priority levels"
flavor data
legal_values 1 to 32
default_value 32
#active_if CYGINT_KERNEL_SCHED_PRIORITY_SCHEDULER
description "
This option controls the number of priority levels that are
available. For some types of scheduler including the bitmap
scheduler this may impose an upper bound on the number of
threads in the system. For other schedulers such as the
mlqueue scheduler the number of threads is independent from
the number of priority levels. Note that the lowest priority
level is normally used only by the idle thread, although
application threads can run at this priority if necessary."
 
cdl_option CYGNUM_KERNEL_SCHED_BITMAP_SIZE {
display "Bitmap size"
flavor data
calculated {"CYGNUM_KERNEL_SCHED_PRIORITIES"}
description "
This option automatically defines the size of bitmap
used to track occupied priority levels."
}
 
cdl_option CYGIMP_KERNEL_SCHED_SORTED_QUEUES {
display "Dequeue oldest threads first"
flavor bool
default_value 0
description "
With this option enabled, threads queued in a thread queue
will be dequeued in priority order, rather than last in,
first out (LIFO). Threads of equal priority are dequeued
oldest first. The only exception is the scheduler run
queues where order is less important as each is already
sorted by priority. Note that this makes the thread queueing
less deterministic."
}
}
 
# ---------------------------------------------------------------------
# Timeslice options
 
# NOTE: this option only makes sense for some of the schedulers.
# Timeslicing is irrelevant for bitmap schedulers.
cdl_component CYGSEM_KERNEL_SCHED_TIMESLICE {
display "Scheduler timeslicing"
requires !CYGSEM_KERNEL_SCHED_BITMAP
requires CYGVAR_KERNEL_COUNTERS_CLOCK
default_value 1
description "
Some schedulers including the mlqueue scheduler support
timeslicing. This means that the kernel will check regularly
whether or not there is another runnable thread with the
same priority, and if there is such a thread there will be
an automatic context switch. Not all applications require
timeslicing, for example because every thread performs a
blocking operation regularly. For these applications it is
possible to disable timeslicing, which reduces the overheads
associated with timer interrupts."
 
cdl_option CYGNUM_KERNEL_SCHED_TIMESLICE_TICKS {
display "Number of clock ticks between timeslices"
flavor data
legal_values 1 to 65535
default_value 5
description "
Assuming timeslicing is enabled, how frequently should it
take place? The value of this option corresponds to the
number of clock ticks that should occur before a timeslice
takes place, so increasing the value reduces the frequency
of timeslices."
}
 
cdl_option CYGSEM_KERNEL_SCHED_TIMESLICE_ENABLE {
display "Support runtime enable of timeslice per-thread"
flavor bool
default_value false
description "This option makes timslicing a per-thread runtime
option. When enabled, threads may have timeslicing
turned on or off dynamically. This is generally used
by higher level APIs (such as POSIX) to implement
differing scheduling policies."
 
}
}
 
# ---------------------------------------------------------------------
# ASR support options
 
cdl_component CYGSEM_KERNEL_SCHED_ASR_SUPPORT {
display "Enable ASR support"
flavor bool
default_value false
description "
This component controls support for Asynchronous Service
Routines (ASRs). This is a function that may be called
from the scheduler when it has just exited the scheduler
lock. This is primarily for use by API compatibility layers."
 
cdl_option CYGSEM_KERNEL_SCHED_ASR_GLOBAL {
display "Make ASR function global"
flavor bool
default_value true
description "
This option controls whether the ASR function is shared by
all threads, or whether each thread may have its own ASR
function."
}
 
cdl_option CYGSEM_KERNEL_SCHED_ASR_DATA_GLOBAL {
display "Make ASR data global"
flavor bool
default_value true
description "
This option controls whether the ASR data is shared by
all threads, or whether each thread may have its own ASR
data. This is independent of the previous option because
it may be useful to pass per-thread data to a shared ASR
function."
}
}
 
# EOF scheduler.cdl
/interrupts.cdl
0,0 → 1,129
# ====================================================================
#
# interrupts.cdl
#
# configuration data related to kernel interrupt handling
#
# ====================================================================
#####ECOSGPLCOPYRIGHTBEGIN####
## -------------------------------------------
## This file is part of eCos, the Embedded Configurable Operating System.
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
##
## eCos is free software; you can redistribute it and/or modify it under
## the terms of the GNU General Public License as published by the Free
## Software Foundation; either version 2 or (at your option) any later version.
##
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY
## WARRANTY; without even the implied warranty of MERCHANTABILITY or
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
## for more details.
##
## You should have received a copy of the GNU General Public License along
## with eCos; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
##
## As a special exception, if other files instantiate templates or use macros
## or inline functions from this file, or you compile this file and link it
## with other works to produce a work based on this file, this file does not
## by itself cause the resulting work to be covered by the GNU General Public
## License. However the source code for this file must still be made available
## in accordance with section (3) of the GNU General Public License.
##
## This exception does not invalidate any other reasons why a work based on
## this file might be covered by the GNU General Public License.
##
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
## at http://sources.redhat.com/ecos/ecos-license/
## -------------------------------------------
#####ECOSGPLCOPYRIGHTEND####
# ====================================================================
######DESCRIPTIONBEGIN####
#
# Author(s): bartv
# Original data: nickg
# Contributors:
# Date: 1999-06-13
#
#####DESCRIPTIONEND####
#
# ====================================================================
 
# NOTE: the choice of list vs table should not be two separate
# options. There is a single option which must have one of
# two legal values.
cdl_component CYGIMP_KERNEL_INTERRUPTS_DSRS {
display "Use delayed service routines (DSRs)"
default_value 1
description "
In eCos the recommended way to handle device interrupts is to
do a minimum amount of work inside the low level interrupt
handler itself, and instead do as much as possible in a
Delayed Service Routine or DSR. If an application does not
make use of DSRs directly or indirectly then it is possible
to disable the DSR support completely, which reduces the
overheads of context switches and interrupt handling. Note
that the kernel real-time clock makes use of DSRs, as do many
of the device drivers. "
 
cdl_interface CYGINT_KERNEL_INTERRUPTS_DSRS {
requires 1 == CYGINT_KERNEL_INTERRUPTS_DSRS
no_define
}
 
# NOTE: the choice of list vs table should not be two separate
# options. There is a single option which must have one of
# two legal values.
cdl_option CYGIMP_KERNEL_INTERRUPTS_DSRS_LIST {
display "Use linked lists for DSRs"
default_value 1
implements CYGINT_KERNEL_INTERRUPTS_DSRS
description "
When DSR support is enabled the kernel must keep track of all
the DSRs that are pending. This information can be kept in a
fixed-size table or in a linked list. The list implementation
requires that the kernel disable interrupts for a very short
period of time outside interrupt handlers, but there is no
possibility of a table overflow occurring."
}
 
cdl_component CYGIMP_KERNEL_INTERRUPTS_DSRS_TABLE {
display "Use fixed-size table for DSRs"
default_value 0
implements CYGINT_KERNEL_INTERRUPTS_DSRS
description "
When DSR support is enabled the kernel must keep track of all
the DSRs that are pending. This information can be kept in a
fixed-size table or in a linked list. The table
implementation involves a very small risk of overflow at
run-time if a given interrupt source is able to have more
than one pending DSR. However it has the advantage that
the kernel does not need to disable interrupts outside
interrupt handlers."
 
cdl_option CYGNUM_KERNEL_INTERRUPTS_DSRS_TABLE_SIZE {
display "Number of entries in fixed-size DSR table"
flavor data
legal_values 2 to 1024
default_value 32
description "
When DSR support is enabled the kernel must keep track of all
the DSRs that are pending. One approach involves a fixed-size
table, which involves a very small risk of overflow at
run-time. By increasing the table size it is possible to reduce
this risk."
}
}
 
cdl_option CYGIMP_KERNEL_INTERRUPTS_CHAIN {
display "Chain all interrupts together"
requires CYGIMP_HAL_COMMON_INTERRUPTS_CHAIN
default_value 0
description "
Interrupts can be attached to vectors either singly, or be
chained together. The latter is necessary if there is no way
of discovering which device has interrupted without
inspecting the device itself. It can also reduce the amount
of RAM needed for interrupt decoding tables and code."
}
}
/kernel.cdl
0,0 → 1,337
# ====================================================================
#
# kernel.cdl
#
# eCos kernel configuration data
#
# ====================================================================
#####ECOSGPLCOPYRIGHTBEGIN####
## -------------------------------------------
## This file is part of eCos, the Embedded Configurable Operating System.
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
##
## eCos is free software; you can redistribute it and/or modify it under
## the terms of the GNU General Public License as published by the Free
## Software Foundation; either version 2 or (at your option) any later version.
##
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY
## WARRANTY; without even the implied warranty of MERCHANTABILITY or
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
## for more details.
##
## You should have received a copy of the GNU General Public License along
## with eCos; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
##
## As a special exception, if other files instantiate templates or use macros
## or inline functions from this file, or you compile this file and link it
## with other works to produce a work based on this file, this file does not
## by itself cause the resulting work to be covered by the GNU General Public
## License. However the source code for this file must still be made available
## in accordance with section (3) of the GNU General Public License.
##
## This exception does not invalidate any other reasons why a work based on
## this file might be covered by the GNU General Public License.
##
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
## at http://sources.redhat.com/ecos/ecos-license/
## -------------------------------------------
#####ECOSGPLCOPYRIGHTEND####
# ====================================================================
######DESCRIPTIONBEGIN####
#
# Author(s): bartv
# Original data: nickg
# Contributors:
# Date: 1999-06-13
#
#####DESCRIPTIONEND####
#
# ====================================================================
 
cdl_package CYGPKG_KERNEL {
display "eCos kernel"
doc ref/kernel.html
include_dir cyg/kernel
description "
This package contains the core functionality of the eCos
kernel. It relies on functionality provided by various HAL
packages and by the eCos infrastructure. In turn the eCos
kernel provides support for other packages such as the device
drivers and the uITRON compatibility layer."
# FIXME: The compile statement should be split up and integrated as
# part of the components - so files only get comiled when they
# will actually be used.
compile common/clock.cxx common/timer.cxx common/kapi.cxx \
common/thread.cxx common/except.cxx \
intr/intr.cxx \
sched/bitmap.cxx sched/lottery.cxx sched/mlqueue.cxx \
sched/sched.cxx \
sync/bin_sem.cxx sync/cnt_sem.cxx sync/flag.cxx \
sync/cnt_sem2.cxx sync/mbox.cxx sync/mutex.cxx \
debug/dbg-thread-demux.c
 
# ---------------------------------------------------------------------
# The first component within the kernel is related to interrupt
# handling.
cdl_component CYGPKG_KERNEL_INTERRUPTS {
display "Kernel interrupt handling"
flavor none
doc ref/kernel-interrupts.html
description "
The majority of configuration options related to interrupt
handling are in the HAL packages, since usually the code has
to be platform-specific. There are a number of options
provided within the kernel related to slightly higher-level
concepts, for example Delayed Service Routines."
 
script interrupts.cdl
}
 
# ---------------------------------------------------------------------
# Exceptions. Currently there are only two options. The first
# determines whether or not exceptions are enabled at all. The
# second controls whether they apply globally or on a per-thread
# basis. There should probably be more options, but the boundary
# between the HAL and kernel becomes blurred.
cdl_component CYGPKG_KERNEL_EXCEPTIONS {
display "Exception handling"
requires CYGPKG_HAL_EXCEPTIONS
default_value 1
doc ref/kernel-exceptions.html
description "
In the context of the eCos kernel exceptions are unexpected
events detected by the hardware, for example an attempt to
execute an illegal instruction. There is no relation with
other forms of exception, for example the catch and throw
facilities of languages like C++. It is possible to disable
all support for exceptions and thus save some memory."
 
cdl_option CYGSEM_KERNEL_EXCEPTIONS_DECODE {
display "Decode exception types in kernel"
default_value 0
description "
On targets where several different types of exception are
possible, for example executing an illegal instruction and
division by zero, it is possible for the kernel to do some
decoding of the exception type and deliver the different
types of exception to different handlers in the application
code. Alternatively the kernel can simply pass all
exceptions directly to application code, leaving the
decoding to be done by the application"
}
 
cdl_option CYGSEM_KERNEL_EXCEPTIONS_GLOBAL {
display "Use global exception handlers"
default_value 1
description "
In the context of the eCos kernel exceptions are
unexpected events detected by the hardware, for
example an attempt to execute an illegal
instruction. If the kernel is configured
to support exceptions then two implementations are
possible. The default implementation involves a single set
of exception handlers that are in use for the entire
system. The alternative implementation allows different
exception handlers to be specified for each thread."
}
}
 
# ---------------------------------------------------------------------
cdl_component CYGPKG_KERNEL_SCHED {
display "Kernel schedulers"
flavor none
doc ref/kernel-overview.html#KERNEL-OVERVIEW-SCHEDULERS
description "
The eCos kernel provides a choice of schedulers. In addition
there are a number of configuration options to control the
detailed behaviour of these schedulers."
 
script scheduler.cdl
}
 
# ---------------------------------------------------------------------
# SMP support
cdl_component CYGPKG_KERNEL_SMP_SUPPORT {
display "SMP support"
flavor bool
requires CYGPKG_HAL_SMP_SUPPORT
default_value 0
}
# ---------------------------------------------------------------------
cdl_component CYGPKG_KERNEL_COUNTERS {
display "Counters and clocks"
flavor none
doc ref/kernel-counters.html
description "
The counter objects provided by the kernel provide an
abstraction of the clock facility that is generally provided.
Application code can associate alarms with counters, where an
alarm is identified by the number of ticks until it triggers,
the action to be taken on triggering, and whether or not the
alarm should be repeated."
 
script counters.cdl
}
 
# ---------------------------------------------------------------------
cdl_component CYGPKG_KERNEL_THREADS {
display "Thread-related options"
flavor none
description "
There are a number of configuration options related to the
implementation of threads, for example whether or not the
eCos kernel supports per-thread data."
 
script thread.cdl
}
 
# ---------------------------------------------------------------------
cdl_component CYGPKG_KERNEL_SYNCH {
display "Synchronization primitives"
flavor none
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."
 
script synch.cdl
}
 
# ---------------------------------------------------------------------
cdl_component CYGPKG_KERNEL_INSTRUMENT {
display "Kernel instrumentation"
flavor bool
default_value 0
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."
 
compile instrmnt/meminst.cxx
script instrument.cdl
}
 
#===================================================================
# Options related to source-level debugging and diagnostics.
cdl_component CYGPKG_KERNEL_DEBUG {
display "Source-level debugging support"
flavor none
description "
If the source level debugger gdb is to be used for debugging
application code then it may be necessary to configure in support
for this in the kernel."
 
# NOTE: does this require any other support ?
cdl_option CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT {
display "Include GDB multi-threading debug support"
requires CYGVAR_KERNEL_THREADS_LIST
requires CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT
default_value 1
compile debug/dbg_gdb.cxx
description "
This option enables some extra kernel code which is needed
to support multi-threaded source level debugging."
}
}
 
# ---------------------------------------------------------------------
# Kernel API's. The C++ one is the default. A C API is optional.
# Support for other languages is possible.
cdl_component CYGPKG_KERNEL_API {
display "Kernel APIs"
flavor none
description "
The eCos kernel is implemented in C++, so a C++ interface
to the kernel is always available. There is also an optional
C API. Additional API's may be provided in future versions."
 
cdl_option CYGFUN_KERNEL_API_C {
display "Provide C API"
default_value 1
description "
The eCos kernel is implemented in C++, but there is an
optional C API for use by application code. This C API can be
disabled if the application code does not invoke the kernel
directly, but instead uses higher level code such as the
uITRON compatibility layer."
}
}
 
define_proc {
puts $::cdl_header "/***** proc output start *****/"
 
# Clients of pkgconf/kernel.h expects system.h to be included.
puts $::cdl_header "#include <pkgconf/system.h>"
# FIXME: Some clients may rely on hal.h and infra.h being included.
# This should go away when any such client has been fixed.
puts $::cdl_header "#include <pkgconf/hal.h>"
puts $::cdl_header "#include <pkgconf/infra.h>"
 
# Include HAL/Platform specifics
puts $::cdl_header "#include CYGBLD_HAL_PLATFORM_H"
# Fallback defaults (in case HAL didn't define these)
puts $::cdl_header "#ifndef CYGNUM_HAL_RTC_NUMERATOR"
puts $::cdl_header "# define CYGNUM_HAL_RTC_NUMERATOR 1000000000"
puts $::cdl_header "# define CYGNUM_HAL_RTC_DENOMINATOR 100"
puts $::cdl_header "# define CYGNUM_HAL_RTC_PERIOD 9999"
puts $::cdl_header "#endif"
 
puts $::cdl_header "/***** proc output end *****/"
}
 
cdl_component CYGPKG_KERNEL_OPTIONS {
display "Kernel build options"
flavor none
description "
Package specific build options including control over
compiler flags used only in building this package,
and details of which tests are built."
 
 
cdl_option CYGPKG_KERNEL_CFLAGS_ADD {
display "Additional compiler flags"
flavor data
no_define
default_value { "" }
description "
This option modifies the set of compiler flags for
building the eCos kernel. These flags are used in addition
to the set of global flags."
}
 
cdl_option CYGPKG_KERNEL_CFLAGS_REMOVE {
display "Suppressed compiler flags"
flavor data
no_define
default_value { "" }
description "
This option modifies the set of compiler flags for
building the eCos kernel. These flags are removed from
the set of global flags if present."
}
 
cdl_option CYGPKG_KERNEL_TESTS {
display "Kernel tests"
flavor data
no_define
calculated {
"tests/bin_sem0 tests/bin_sem1 tests/bin_sem2 tests/clock0 tests/clock1 tests/clockcnv tests/clocktruth tests/cnt_sem0 tests/cnt_sem1 tests/except1 tests/flag0 tests/flag1 tests/intr0 tests/kill tests/mbox1 tests/mqueue1 tests/mutex0 tests/mutex1 tests/mutex2 tests/mutex3 tests/release tests/sched1 tests/sync2 tests/sync3 tests/thread0 tests/thread1 tests/thread2"
. ((CYGFUN_KERNEL_API_C) ? " tests/kclock0 tests/kclock1 tests/kexcept1 tests/kflag0 tests/kflag1 tests/kintr0 tests/klock tests/kmbox1 tests/kmutex0 tests/kmutex1 tests/kmutex3 tests/kmutex4 tests/ksched1 tests/ksem0 tests/ksem1 tests/kthread0 tests/kthread1 tests/stress_threads tests/thread_gdb tests/timeslice tests/tm_basic tests/fptest" : "")
. ((!CYGPKG_INFRA_DEBUG && !CYGPKG_KERNEL_INSTRUMENT && CYGFUN_KERNEL_API_C) ? " tests/dhrystone" : "")
. ((CYGPKG_KERNEL_SMP_SUPPORT && CYGFUN_KERNEL_API_C) ? " tests/smp" : "")
. ((!CYGINT_HAL_TESTS_NO_CACHES && CYGFUN_KERNEL_API_C) ? " tests/kcache1 tests/kcache2" : "")
}
description "
This option specifies the set of tests for the eCos kernel."
}
}
}
 
# EOF kernel.cdl
/counters.cdl
0,0 → 1,251
# ====================================================================
#
# counters.cdl
#
# configuration data related to the kernel counters and clocks
#
# ====================================================================
#####ECOSGPLCOPYRIGHTBEGIN####
## -------------------------------------------
## This file is part of eCos, the Embedded Configurable Operating System.
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
##
## eCos is free software; you can redistribute it and/or modify it under
## the terms of the GNU General Public License as published by the Free
## Software Foundation; either version 2 or (at your option) any later version.
##
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY
## WARRANTY; without even the implied warranty of MERCHANTABILITY or
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
## for more details.
##
## You should have received a copy of the GNU General Public License along
## with eCos; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
##
## As a special exception, if other files instantiate templates or use macros
## or inline functions from this file, or you compile this file and link it
## with other works to produce a work based on this file, this file does not
## by itself cause the resulting work to be covered by the GNU General Public
## License. However the source code for this file must still be made available
## in accordance with section (3) of the GNU General Public License.
##
## This exception does not invalidate any other reasons why a work based on
## this file might be covered by the GNU General Public License.
##
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
## at http://sources.redhat.com/ecos/ecos-license/
## -------------------------------------------
#####ECOSGPLCOPYRIGHTEND####
# ====================================================================
######DESCRIPTIONBEGIN####
#
# Author(s): jskov
# Original data: nickg
# Contributors:
# Date: 1999-07-05
#
#####DESCRIPTIONEND####
#
# ====================================================================
 
cdl_option CYGVAR_KERNEL_COUNTERS_CLOCK {
display "Provide real-time clock"
requires CYGIMP_KERNEL_INTERRUPTS_DSRS
default_value 1
description "
On all current target systems the kernel can provide a
real-time clock. This clock serves two purposes. First it is
necessary to support clock and alarm related functions.
Second it is needed to implement timeslicing in some of the
schedulers including the mlqueue scheduler. If the
application does not require any of these facilities then it
is possible to disable the real time clock support
completely."
}
 
cdl_component CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE {
display "Override default clock settings"
requires CYGVAR_KERNEL_COUNTERS_CLOCK
default_value 0
description "
The kernel has default settings for the clock interrupt
frequency. These settings will vary from platform to
platform, but typically there will be a 100 clock interrupts
every second. It is possible to change this frequency, but
it requires some knowledge of the target hardware."
 
cdl_option CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_PERIOD {
display "Clock hardware initialization value"
flavor data
legal_values 1 to 0x7fffffff
default_value 9999
description "
During system initialization this value is used to initialize
the clock hardware. The exact meaning of the value and the
range of legal values therefore depends on the target hardware,
and the hardware documentation should be consulted for further
details. In addition the clock resolution numerator and
denominator values should be updated. Typical values for
this option would be 150000 on the MN10300 stdeval1 board,
15625 on the tx39 jmr3904 board, and 20833 on the powerpc
cogent board."
}
 
cdl_option CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_NUMERATOR {
display "Clock resolution numerator"
flavor data
legal_values 1 to 0x7fffffff
default_value 1000000000
description "
If a non-default clock interrupt frequency is used then it
is necessary to specify the clock resolution explicitly.
This resolution involves two separate values, the numerator
and the denominator. The result of dividing the numerator by
the denominator should correspond to the number of
nanoseconds between clock interrupts. For example a
numerator of 1000000000 and a denominator of 100 means that
there are 10000000 nanoseconds (or 10 milliseconds) between
clock interrupts. Expressing the resolution as a fraction
should minimize clock drift even for frequencies that cannot
be expressed as a simple integer. For example a frequency of
60Hz corresponds to a clock resolution of 16666666.66...
nanoseconds. This can be expressed accurately as 1000000000
over 60."
}
 
cdl_option CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_DENOMINATOR {
display "Clock resolution denominator"
flavor data
legal_values 1 to 0x7fffffff
default_value 100
description "
If a non-default clock interrupt frequency is used then it
is necessary to specify the clock resolution explicitly.
This resolution involves two separate values, the numerator
and the denominator. The result of dividing the numerator by
the denominator should correspond to the number of
nanoseconds between clock interrupts. For example a
numerator of 1000000000 and a denominator of 100 means that
there are 10000000 nanoseconds (or 10 milliseconds) between
clock interrupts. Expressing the resolution as a fraction
should minimize clock drift even for frequencies that cannot
be expressed as a simple integer. For example a frequency of
60Hz corresponds to a clock resolution of 16666666.66...
nanoseconds. This can be expressed accurately as 1000000000
over 60."
}
}
 
cdl_interface CYGINT_KERNEL_COUNTERS {
requires 1 == CYGINT_KERNEL_COUNTERS
no_define
}
 
# NOTE: these option should really be a single enum.
cdl_option CYGIMP_KERNEL_COUNTERS_SINGLE_LIST {
display "Implement counters using a single list"
default_value 1
implements CYGINT_KERNEL_COUNTERS
description "
There are two different implementations of the counter
objects. The first implementation stores all alarms in a
single linked list. The alternative implementation uses a
table of linked lists. A single list is more efficient in
terms of memory usage and is generally adequate when the
application only makes use of a small number of alarms."
}
 
cdl_component CYGIMP_KERNEL_COUNTERS_MULTI_LIST {
display "Implement counters using a table of lists"
default_value 0
implements CYGINT_KERNEL_COUNTERS
description "
There are two different implementations of the counter
objects. The first implementation stores all alarms in a
single linked list. The alternative implementation uses a
table of linked lists, with the size of the table being a
separate configurable option. For more complicated
operations it is better to have a table of lists since this
reduces the amount of computation whenever the timer goes
off. Assuming a table size of 8 (the default value) on
average the timer code will only need to check 1/8 of the
pending alarms instead of all of them."
 
cdl_option CYGNUM_KERNEL_COUNTERS_MULTI_LIST_SIZE {
display "Size of counter list table"
flavor data
legal_values 1 to 1024
default_value 8
description "
If counters are implemented using an array of linked lists
then this option controls the size of the array. A larger
size reduces the amount of computation that needs to take
place whenever the timer goes off, but requires extra
memory."
}
}
 
cdl_option CYGIMP_KERNEL_COUNTERS_SORT_LIST {
display "Sort the counter list"
default_value 0
description "
Sorting the counter lists reduces the amount of work that
has to be done when a counter tick is processed, since the
next alarm to expire is always at the front of the list.
However, it makes adding an alarm to the list more expensive
since a search must be done for the correct place to put it.
Many alarms are used to implement timeouts, which seldom trigger,
so it is worthwhile optimizing this case. For this reason
sorted list are disabled by default."
}
 
cdl_option CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY {
display "Measure real-time \[clock\] interrupt latency"
requires CYGVAR_KERNEL_COUNTERS_CLOCK
default_value 0
description "
Measure the interrupt latency as seen by the real-time clock
timer interrupt. This requires hardware support, defined by
the HAL_CLOCK_LATENCY() macro."
}
 
cdl_option CYGVAR_KERNEL_COUNTERS_CLOCK_DSR_LATENCY {
display "Measure real-time \[clock\] DSR latency"
requires CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY
default_value CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY
description "
Measure the DSR latency as seen by the real-time clock
timer interrupt. This requires hardware support, defined by
the HAL_CLOCK_LATENCY() macro."
}
 
cdl_option CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION {
display "RTC resolution"
flavor data
calculated { CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE ? \
"{CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_NUMERATOR, \
CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_DENOMINATOR}" \
: "{CYGNUM_HAL_RTC_NUMERATOR, CYGNUM_HAL_RTC_DENOMINATOR}"}
description "
This option automatically defines the tuple which is used to
initialize the RTC resolution, consisting of a numerator and
denominator. For more information, see the option to
override default clock settings
(CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE) and associated options."
}
 
cdl_option CYGNUM_KERNEL_COUNTERS_RTC_PERIOD {
display "RTC period"
flavor data
calculated { CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE ? \
"CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_PERIOD" \
: "CYGNUM_HAL_RTC_PERIOD"}
description "
This option automatically defines the RTC period to be used in
setting the system clock hardware. For more information, see the
option to override default clock settings
(CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE) and associated options."
}
 
# EOF counters.cdl
/synch.cdl
0,0 → 1,213
# ====================================================================
#
# synch.cdl
#
# configuration data related to the kernel synchronization primitives
#
# ====================================================================
#####ECOSGPLCOPYRIGHTBEGIN####
## -------------------------------------------
## This file is part of eCos, the Embedded Configurable Operating System.
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
##
## eCos is free software; you can redistribute it and/or modify it under
## the terms of the GNU General Public License as published by the Free
## Software Foundation; either version 2 or (at your option) any later version.
##
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY
## WARRANTY; without even the implied warranty of MERCHANTABILITY or
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
## for more details.
##
## You should have received a copy of the GNU General Public License along
## with eCos; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
##
## As a special exception, if other files instantiate templates or use macros
## or inline functions from this file, or you compile this file and link it
## with other works to produce a work based on this file, this file does not
## by itself cause the resulting work to be covered by the GNU General Public
## License. However the source code for this file must still be made available
## in accordance with section (3) of the GNU General Public License.
##
## This exception does not invalidate any other reasons why a work based on
## this file might be covered by the GNU General Public License.
##
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
## at http://sources.redhat.com/ecos/ecos-license/
## -------------------------------------------
#####ECOSGPLCOPYRIGHTEND####
# ====================================================================
######DESCRIPTIONBEGIN####
#
# Author(s): jskov
# Original data: nickg
# Contributors:
# Date: 1999-07-05
#
#####DESCRIPTIONEND####
#
# ====================================================================
 
 
cdl_component CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL {
display "Priority inversion protection protocols"
flavor booldata
doc ref/kernel-mutexes.html
legal_values { "SIMPLE" }
default_value { "SIMPLE" }
active_if { CYGSEM_KERNEL_SCHED_MLQUEUE }
requires { CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES == 0 }
description "
This component controls the protocols used to protect mutexes against
priority inversion. If this option is enabled it defines which
algorithm is used to implement this protection. At present only
one such algorithm is defined: \"SIMPLE\". 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."
 
cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_INHERIT {
display "Enable priority inheritance protocol"
default_value 1
implements CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT
description "
This option enables priority inheritance protocol. This protocol
causes the owner of a mutex to be executed at the highest priority
of the threads waiting for access to the mutex."
}
 
cdl_component CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING {
display "Enable priority ceiling protocol"
default_value 1
implements CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT
description "
This option enables priority ceiling protocol. This protocol
causes the owner of a mutex to be executed at a priority
associated with the mutex."
cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DEFAULT_PRIORITY {
display "Default priority ceiling"
flavor data
legal_values 0 to { CYGNUM_KERNEL_SCHED_PRIORITIES - 1 }
default_value 0
active_if CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING
description "
This option defines the default priority ceiling to be
used if the chosen default priority inversion protocol is
priority ceoptioniling protocol. The default value for this is zero,
making all such mutexes boost threads to the maximum priority."
}
}
 
cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_NONE {
display "No priority inversion protocol"
default_value 1
implements CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT
description "
This option enables the ability to have no priority inversion protocol.
It is equivalent to disabling the priority inversion protocol at
the top level, but is necessary for the runtime and default
selection options."
}
 
cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DEFAULT {
display "Default priority inversion protocol"
flavor data
active_if { CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT > 1 }
legal_values { "INHERIT" "CEILING" "NONE" }
default_value { CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_INHERIT ?
"INHERIT" :
CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING ?
"CEILING" : "NONE" }
description "
This option defines the default inversion protocol used for mutexes that
are created without an explicit protocol being specified. The protocol
chosen by default is to use priority inheritance if it is present otherwise
priority ceiling, or none if neither is present."
}
 
cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DYNAMIC {
display "Specify mutex priority inversion protocol at runtime"
default_value 1
active_if { CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT > 1 }
description "
This option controls whether the priority inversion protocol used by
a mutex can be specified when that mutex is created."
}
cdl_interface CYGINT_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_COUNT {
display "Number of protocols selected"
}
}
 
cdl_option CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT {
display "Message box blocking put support"
doc ref/kernel-mail-boxes.html
default_value 1
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."
}
 
cdl_option CYGNUM_KERNEL_SYNCH_MBOX_QUEUE_SIZE {
display "Message box queue size"
doc ref/kernel-mail-boxes.html
flavor data
legal_values 1 to 65535
default_value 10
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"
doc ref/kernel-condition-variables.html
requires CYGFUN_KERNEL_THREADS_TIMER
default_value 1
description "
This option enables the condition variable timed wait
facility."
}
 
cdl_option CYGMFN_KERNEL_SYNCH_CONDVAR_WAIT_MUTEX {
display "Condition variable explicit mutex wait support"
doc ref/kernel-condition-variables.html
default_value 1
description "
This option enables the condition variable explicit mutex wait
facility. By default condition variables in eCos are created with
a statically associated mutex. This option permits wait (and timed wait
if CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT is enabled) to provide a
different mutex as an argument. This makes no difference to the semantics
the wait operation except that a different mutex will be used during it."
}
 
cdl_option CYGIMP_KERNEL_SYNCH_MQUEUE_NOT_INLINE {
display "Avoid inlines in mqueue implementation"
default_value 0
description "
With this option disabled, the 'mqueue' message queue implementation
provides most of its implementation via inlines. However this can
adversely affect code size in application that make lots of mqueue
calls from different places, so enabling this option provides
non-inline versions to be used instead."
compile sync/mqueue.cxx
}
 
# EOF synch.cdl
/thread.cdl
0,0 → 1,332
# ====================================================================
#
# thread.cdl
#
# configuration data related to the kernel threads
#
# ====================================================================
#####ECOSGPLCOPYRIGHTBEGIN####
## -------------------------------------------
## This file is part of eCos, the Embedded Configurable Operating System.
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
##
## eCos is free software; you can redistribute it and/or modify it under
## the terms of the GNU General Public License as published by the Free
## Software Foundation; either version 2 or (at your option) any later version.
##
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY
## WARRANTY; without even the implied warranty of MERCHANTABILITY or
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
## for more details.
##
## You should have received a copy of the GNU General Public License along
## with eCos; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
##
## As a special exception, if other files instantiate templates or use macros
## or inline functions from this file, or you compile this file and link it
## with other works to produce a work based on this file, this file does not
## by itself cause the resulting work to be covered by the GNU General Public
## License. However the source code for this file must still be made available
## in accordance with section (3) of the GNU General Public License.
##
## This exception does not invalidate any other reasons why a work based on
## this file might be covered by the GNU General Public License.
##
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
## at http://sources.redhat.com/ecos/ecos-license/
## -------------------------------------------
#####ECOSGPLCOPYRIGHTEND####
# ====================================================================
######DESCRIPTIONBEGIN####
#
# Author(s): jskov
# Original data: nickg
# Contributors:
# Date: 1999-07-05
#
#####DESCRIPTIONEND####
#
# ====================================================================
 
cdl_option CYGFUN_KERNEL_THREADS_TIMER {
display "Allow per-thread timers"
requires CYGVAR_KERNEL_COUNTERS_CLOCK
default_value 1
description "
This option controls whether or not the kernel should support
per-thread clock and alarm related functions. Also some of
the synchronization primitives such as semaphore and
condition variable timed wait operations require per-thread
timer support. If none of these facilities are required then
the option can be disabled."
}
 
cdl_option CYGVAR_KERNEL_THREADS_NAME {
display "Support optional name for each thread"
default_value 1
description "
Threads may optionally be supplied with a name string that is
used to identify them during debugging. This name is only
present if `this option is defined. Disabling it reduces both
code and data size."
}
 
cdl_option CYGVAR_KERNEL_THREADS_LIST {
display "Keep track of all threads using a linked list"
default_value 1
description "
Threads may optionally be placed on a housekeeping list so
that all threads may be located easily. This is useful mainly
in conjunction with source-level debugging."
}
 
cdl_option CYGFUN_KERNEL_THREADS_STACK_LIMIT {
display "Keep track of the base of each thread's stack"
default_value 1
description "
This option makes the kernel keep track of the lower limit on
each thread's stack. It allows the kernel to adjust the lower
limit, thus making space for per-thread data. Note that it
does not imply any form of run-time stack overflow checking."
}
 
cdl_component CYGFUN_KERNEL_THREADS_STACK_CHECKING {
display "Check thread stacks for overflows"
active_if CYGPKG_INFRA_DEBUG
active_if CYGDBG_USE_ASSERTS
default_value 1
description "
This option enables a variety of checks for stack overflow
including signatures at the top and base of thread stacks,
which are asserted for correctness whenever a thread switches."
 
cdl_option CYGFUN_KERNEL_ALL_THREADS_STACK_CHECKING {
display "Check all threads whenever possible"
requires CYGVAR_KERNEL_THREADS_LIST
default_value 0
description "
This option enables more active checking of all threads for
wrongdoing. In theory, checking threads other than the old and new
executing threads in a thread-switch is pointless, because no other
thread has run, so no other stack can be exceeded. But errors such
as memory scribbling, dangling pointers, overlapping use of store
or errors accessing objects adjacent to a stack which can be very
hard to find can be detected this way, saving debug time."
}
 
cdl_option CYGNUM_KERNEL_THREADS_STACK_CHECK_DATA_SIZE {
display "Signature size in bytes, at stack top and bottom"
flavor data
default_value 32
legal_values 8 to 512
description "
This is the size of the area reserved for a signature at the top
and bottom of all stacks. It also provides a buffer zone for
detecting overflow before external objects are corrupted, hence the
ability to vary it here. But if you are short of stack, increasing
this value will make the overflow more, not less likely, of course."
}
}
 
cdl_component CYGFUN_KERNEL_THREADS_STACK_MEASUREMENT {
display "Measure stack usage"
default_value { 0 != CYGPKG_INFRA_DEBUG }
description "
This option allows measurement of each thread's stack by initializing
it to a predefined value at thread creation time. Later use of the
cyg_thread_measure_stack_usage() function allows the maximum stack
usage of the thread so far to be obtained. Note that this is not
necessarily the true maximum stack usage that the thread will ever
use since all that has been measured is the stack usage corresponding
to the code path followed this time, and not the code path that may
be followed in future."
 
cdl_option CYGDBG_KERNEL_THREADS_STACK_MEASUREMENT_VERBOSE_EXIT {
display "Output stack usage on thread exit"
default_value 0
description "
This will output the measured stack usage on the diagnostic
output when a thread exits."
}
}
 
cdl_component CYGVAR_KERNEL_THREADS_DATA {
display "Support for per-thread data"
requires CYGFUN_KERNEL_THREADS_STACK_LIMIT
doc ref/kernel-thread-data.html
default_value 1
description "
It is possible for the kernel to support per-thread data, in
other words an area of memory specific to each thread which
can be used to store data for that thread. This per-thread
data can be used by applications or by other packages such as
the ISO C library."
 
cdl_option CYGNUM_KERNEL_THREADS_DATA_MAX {
display "Number of words of per-thread data"
flavor data
legal_values 4 to 32
default_value 6
description "
It is possible for the kernel to support per-thread data, in
other words an area of memory specific to each thread which
can be used to store data for that thread. This per-thread
data can be used by applications or by other packages such as
the ISO C library. This configuration option controls the
number of words of per-thread data that the kernel will
allow. In the current implementation a bitmask is used to identify
used per-thread data slots and so the maximum legal value must
remain 32."
}
 
cdl_component CYGNUM_KERNEL_THREADS_DATA_ALL {
display "Bitmap of preallocated slots of thread data"
flavor data
calculated 15
description "
Per thread data options. Per thread data support is based loosely
on that defined by POSIX. Each thread has an array of slots, up to
CYGNUM_KERNEL_THREADS_DATA_MAX, that may contain data. Some of the
slots have been preallocated to specific packages. Others may be
allocated dynamically."
 
cdl_option CYGNUM_KERNEL_THREADS_DATA_KERNEL {
display "Slot 0 preallocated for the kernel"
flavor data
calculated 0
description "
This option defines the index of a per-thread data
slot which is reserved by
the eCos kernel
for private use."
}
cdl_option CYGNUM_KERNEL_THREADS_DATA_ITRON {
display "Slot 1 preallocated for uITRON"
flavor data
calculated 1
description "
This option defines the index of a per-thread data
slot which is reserved by
the uITRON compatibility layer
for private use."
}
cdl_option CYGNUM_KERNEL_THREADS_DATA_ERRNO {
display "Slot 2 preallocated for errno"
flavor data
calculated 2
description "
This option defines the index of a per-thread data
slot which is reserved for use by an errno variable."
}
cdl_option CYGNUM_KERNEL_THREADS_DATA_POSIX {
display "Slot 3 preallocated for POSIX"
flavor data
calculated 3
description "
This option defines the index of a per-thread data
slot which is reserved by
POSIX
for private use."
}
}
}
 
cdl_component CYGPKG_KERNEL_THREADS_DESTRUCTORS {
display "Thread destructors"
doc ref/kernel-thread-destructors.html
default_value 0
description "
This option enables support for registered destructor functions to
be called on thread exit."
 
cdl_option CYGNUM_KERNEL_THREADS_DESTRUCTORS {
display "Number of possible destructors"
flavor data
legal_values 1 to 65535
default_value 8
description "
This option gives the number of possible destructors allowed.
Increasing this will increase the size of every
thread control structure if per-thread destructors are
enabled."
}
cdl_option CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD {
display "Per-thread destructors"
default_value 1
description "
Enabling this option makes the thread destructors a per-thread
property, with each thread having its own list of destructors.
Disabling this option makes the thread destructor list
global so all threads have the same destructors."
}
}
 
cdl_option CYGNUM_KERNEL_THREADS_IDLE_STACK_SIZE {
display "Stack size for the idle thread"
flavor data
legal_values 512 to 65536
default_value 2048
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."
}
 
# ---------------------------------------------------------------------
# Thread-related miscellania.
 
cdl_option CYGNUM_KERNEL_MAX_SUSPEND_COUNT_ASSERT {
display "Maximal suspend count"
flavor data
default_value 500
description "
This option provides for an assertion that the count value for
counted thread suspends do not exceed set limits. This is to help
with debugging, to allow a runaway loop, for example, to be
detected more easily.
If the option is not defined, no assert is included. Whether asserts
are themselves included depends on infrastructure configury in
infra.h"
}
 
cdl_option CYGNUM_KERNEL_MAX_COUNTED_WAKE_COUNT_ASSERT {
display "Maximal wake count"
flavor data
default_value 500
description "
This option provides for an assertion that the count value for
counted thread wakeups do not exceed set limits. This is to
help with debugging, to allow a runaaway loop, for example, to
be detected more easily.
If the option is not defined, no assert is included. Whether asserts
are themselves included depends on infrastructure configury in
infra.h"
}
 
 
#if CYGNUM_KERNEL_SCHED_PRIORITIES == 1
# define CYGIMP_IDLE_THREAD_YIELD
#endif
cdl_option CYGIMP_IDLE_THREAD_YIELD {
display "Idle thread must always yield"
calculated 1
active_if (CYGNUM_KERNEL_SCHED_PRIORITIES == 1)
description "
If the scheduler configuration only has a single priority
level, then the idle thread must yield each time around its loop."
}
 
# EOF thread.cdl
/instrument.cdl
0,0 → 1,312
# ====================================================================
#
# instrument.cdl
#
# configuration data related to the kernel instrumentation
#
# ====================================================================
#####ECOSGPLCOPYRIGHTBEGIN####
## -------------------------------------------
## This file is part of eCos, the Embedded Configurable Operating System.
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
##
## eCos is free software; you can redistribute it and/or modify it under
## the terms of the GNU General Public License as published by the Free
## Software Foundation; either version 2 or (at your option) any later version.
##
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY
## WARRANTY; without even the implied warranty of MERCHANTABILITY or
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
## for more details.
##
## You should have received a copy of the GNU General Public License along
## with eCos; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
##
## As a special exception, if other files instantiate templates or use macros
## or inline functions from this file, or you compile this file and link it
## with other works to produce a work based on this file, this file does not
## by itself cause the resulting work to be covered by the GNU General Public
## License. However the source code for this file must still be made available
## in accordance with section (3) of the GNU General Public License.
##
## This exception does not invalidate any other reasons why a work based on
## this file might be covered by the GNU General Public License.
##
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
## at http://sources.redhat.com/ecos/ecos-license/
## -------------------------------------------
#####ECOSGPLCOPYRIGHTEND####
# ====================================================================
######DESCRIPTIONBEGIN####
#
# Author(s): jskov
# Original data: nickg
# Contributors:
# Date: 1999-07-05
#
#####DESCRIPTIONEND####
#
# ====================================================================
 
cdl_option CYGVAR_KERNEL_INSTRUMENT_EXTERNAL_BUFFER {
display "Use buffer provided by the application"
flavor bool
default_value 0
description "
In most circumstances the kernel should provide the
instrumentation circular buffer itself. Occasionally
application code may wish to provide the buffer instead,
giving the application code more convenient access to the
buffer. This also makes it possible to put the circular
buffer in special areas of memory, for example a region that
is shared with the host."
}
 
cdl_option CYGNUM_KERNEL_INSTRUMENT_BUFFER_SIZE {
display "Size of instrumentation buffer size"
flavor data
legal_values 16 to 0x100000
default_value 256
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_BUFFER_WRAP {
display "Wrap instrument buffer"
default_value 1
description "
When the instrumentation buffer is full it can either be restarted
from the beginning, overwriting older data, or it can stop at the
end. The former is useful if you want to look at the last entries
made while the latter is useful if you want to look at the first
few."
}
 
cdl_option CYGDBG_KERNEL_INSTRUMENT_FLAGS {
display "Perform selective instrumentation"
default_value 1
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."
}
 
cdl_option CYGDBG_KERNEL_INSTRUMENT_SCHED {
display "Instrument the scheduler"
default_value 1
active_if CYGPKG_KERNEL_SCHED
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"
default_value 1
active_if CYGPKG_KERNEL_THREADS
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"
default_value 1
active_if CYGPKG_KERNEL_INTERRUPTS
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"
default_value 1
active_if CYGPKG_KERNEL_SYNCH
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"
default_value 1
active_if CYGPKG_KERNEL_SYNCH
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"
default_value 1
active_if CYGPKG_KERNEL_SYNCH
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"
default_value 1
active_if CYGPKG_KERNEL_SYNCH
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"
default_value 1
active_if CYGPKG_KERNEL_SYNCH
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"
default_value 1
active_if CYGVAR_KERNEL_COUNTERS_CLOCK
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"
default_value 1
active_if CYGVAR_KERNEL_COUNTERS_CLOCK
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_SMP {
display "Instrument SMP-related operations"
default_value 1
active_if CYGVAR_KERNEL_COUNTERS_CLOCK
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 SMP operations."
}
 
cdl_option CYGDBG_KERNEL_INSTRUMENT_USER {
display "Support application-level instrumentation"
default_value 1
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."
}
 
cdl_component CYGDBG_KERNEL_INSTRUMENT_MSGS {
display "Print user friendly instrument messages"
default_value 1
description "
Include code which will convert the instrument type field
into a more human understandable string"
cdl_option CYGDBG_KERNEL_INSTRUMENT_MSGS_BUILD_HEADERFILE {
display "Rebuild the header file"
default_value 0
description "
 
Make (using a shell script) include/cyg/kernel/instrument_desc.h in
your build tree; this is normally simply copied from the repository.
If you make a permanent change to include/instrmnt.h, such that
instrument_desc.h needs updating, it's up to you to first delete the
master file
ECOS_REPOSITORY/kernel/VERSION/include/instrument_desc.h
in your source repository, make the new version by enabling this
option then copy the new file
back from your build place to its source in
ECOS_REPOSITORY/kernel/VERSION/include/instrument_desc.h
and/or commit this to any version control system that you use."
 
make -priority 50 {
<PREFIX>/include/cyg/kernel/instrument_desc.h: <PACKAGE>/include/instrmnt.h <PACKAGE>/cdl/instrument.cdl
sh $(REPOSITORY)/$(PACKAGE)/host/instr/instrument.sh $< > $@
}
}
 
cdl_component CYGDBG_KERNEL_INSTRUMENT_BUILD_HOST_DUMP {
display "Build the host tool to print out a dump"
default_value 0
description "
Generate a host program which can dump the instrumentation
data in a human readable format. You have to somehow get the
instrumentation buffer into a file on the host. 'Exercise for
the reader' as university lecturers tend to say."
 
make -priority 51 {
<PREFIX>/bin/dump_instr: <PREFIX>/include/cyg/kernel/instrument_desc.h <PACKAGE>/cdl/instrument.cdl
@mkdir -p $(dir $@)
@mkdir -p tempinc
@cp -r $(PREFIX)/include/cyg tempinc
@cp -r $(PREFIX)/include/pkgconf tempinc
cc -I./tempinc $(REPOSITORY)/$(PACKAGE)/host/instr/dump_instr.c -o $(PREFIX)/bin/dump_instr
@rm -rf tempinc
}
}
}
 
# EOF instrument.cdl

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.