1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
32 33 34 35
36
37 requires ti.sysbios.interfaces;
38 requires ti.sysbios.family;
39
40 /*!
41 * ======== ti.sysbios.knl ========
42 * Contains core threading modules for the SYS/BIOS kernel.
43 *
44 * Many real-time applications must perform a number of functions at the
45 * same time, often in response to external events such as the availability of
46 * data or the presence of a control signal. Both the functions and `when`
47 * they are performed are important.
48 *
49 * Such functions are called "threads". Within SYS/BIOS, the term is defined
50 * broadly to include any independent stream of instructions executed by the
51 * processor. A thread is a single point of control that can activate a
52 * function call or an interrupt service routine (ISR).
53 *
54 * SYS/BIOS enables your applications to be structured as a collection of
55 * threads. Multithreaded programs allow higher-priority threads to preempt
56 * lower-priority threads and allow various types of interaction between
57 * threads, including blocking, communication, and synchronization.
58 *
59 * SYS/BIOS provides support for several types of threads with different
60 * priorities. Each thread type has different execution and preemption
61 * characteristics. The thread types (from highest to lowest priority) are:
62 *
63 * @p(blist)
64 * - Hardware interrupts ({@link ti.sysbios.hal.Hwi}), which includes
65 * {@link ti.sysbios.hal.Timer} functions
66 * - Software interrupts ({@link ti.sysbios.knl.Swi}), which includes
67 * {@link ti.sysbios.knl.Clock} functions
68 * - Tasks ({@link ti.sysbios.knl.Task})
69 * - Background thread ({@link ti.sysbios.knl.Idle})
70 * @p
71 *
72 * The ti.sysbios.knl package also provides several modules for
73 * synchronizing threads.
74 *
75 * @p(blist)
76 * - Semaphores ({@link ti.sysbios.knl.Semaphore}) are often used to
77 * coordinate access to a shared resource
78 * among a set of competing tasks. Semaphores can be used for task
79 * synchronization and mutual exclusion. Semaphore objects can be declared
80 * as either counting or binary semaphores. The same APIs are used for
81 * both counting and binary semaphores.
82 * - Events ({@link ti.sysbios.knl.Event}) provide a means for
83 * communicating between and synchronizing
84 * threads. They are similar to Semaphores, except that they allow you
85 * to specify multiple conditions ("events") that must occur before the
86 * waiting thread returns.
87 * - Mailboxes ({@link ti.sysbios.knl.Mailbox}) can be used to pass buffers
88 * from one thread to another.
89 * A Mailbox instance can be used by multiple readers and writers.
90 * @p
91 *
92 * In addition to Semaphores, Events, and Mailboxes, you can use
93 * Gates to prevent concurrent accesses to critical regions of code.
94 * The {@link xdc.runtime.Gate} module is provided by XDCtools, but
95 * SYS/BIOS
96 * provides some additional implementations in {@link ti.sysbios.gates}.
97 */
98 package ti.sysbios.knl [2,0,0,0] {
99 module Clock;
100 module Idle;
101 module Intrinsics;
102 module Event;
103 module Mailbox;
104 module Queue;
105 module Semaphore;
106 module Swi;
107 module Task;
108 }
109 110 111 112
113