Subversion Repositories openrisc_me

# ====================================================================

#

#      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