Texas Instruments TMS320 DSP 用户手册

Abstract Interface — An interface defined by a C header whose functions are specified by a structure of

function pointers. By convention these interface headers begin with the letter 'i' and the interface
name begins with 'I'. Such an interface is "abstract" because, in general, many modules in a system
implement the same abstract interface; i.e., the interface defines abstract operations supported by
many modules.

Algorithm — Technically, an algorithm is a sequence of operations, each chosen from a finite set of

well-defined operations (e.g., computer instructions), that halts in a finite time, and computes a
mathematical function. In the context of this specification, however, we allow algorithms to employ
heuristics and do not require that they always produce a correct answer.

API — Acronym for Application Programming Interface i.e., a specific set of constants, types, variables,

and functions used to programmatically interact with a piece of software.

Asynchronous System Calls — Most system calls block (or "suspend") the calling thread until they

complete, and continue its execution immediately following the call. Some systems also provide
asynchronous (or non-blocking) forms of these calls; the kernel notifies the caller through some
kind of out-of-band method when such a system call has completed
Asynchronous system calls are generally much harder for the programmer to deal with than
blocking calls. This complexity is often outweighed by the performance benefits for real-time
compute intensive applications.

Client — The term client is often used to denote any piece of software that uses a function, module, or

interface; for example, if the function a() calls the function b(), a() is a client of b(). Similarly, if an
application App uses module MOD, App is a client of MOD.

COFF — Common Output File Format. The file format of the files produced by the TI compiler, assembler,

and linker.

Concrete Interface — An interface defined by a C header whose functions are implemented by a single

module within a system. This is in contrast to an abstract interface where multiple modules in a
system may implement the same abstract interface. The header for every module defines a
concrete interface.

Context Switch — A context switch is the action of switching a CPU between one thread and another (or

transferring control between them). This may involve crossing one or more protection boundaries.

Critical Section — A critical section of code is one in which data that may be accessed by other threads

are inconsistent. At a higher level, a critical section can be viewed as a section of code in which a
guarantee you make to other threads about the state of some data may not be true.
If other threads can access these data during a critical section, your program may not behave
correctly. This may cause it to crash, lock up, produce incorrect results, or do just about any other
unpleasant thing you care to imagine.
Other threads are generally denied access to inconsistent data during a critical section (usually
through use of locks). If some of your critical sections are too long, however, it may result in your
code performing poorly.

SPRU352G – June 2005 – Revised February 2007

85