Computer Hardware Algorithm Standard User's Guide

www.ti.com
Glossary of Terms
Endian — Refers to which bytes are most significant in multi-byte data types. In big-endian architectures,
the leftmost bytes (those with a lower address) are most significant. In little-endian architectures,
the rightmost bytes are most significant.
HP, IBM, Motorola 68000, and SPARC systems store multi-byte values in big-endian order, while
Intel 80x86, DEC VAX, and DEC Alpha systems store them in little-endian order. Internet standard
byte ordering is also big-endian. The TMS320C6000 is bi-endian because it supports both systems.
Frame — Algorithms often process multiple samples of data at a time. This set of samples is sometimes
referred to as a frame. In addition to improving performance, some algorithms require specific
minimum frame sizes to properly operate.
Framework — A framework is that part of an application that has been designed to remain invariant while
selected software components are added, removed, or modified. Very general frameworks are
sometimes described as application specific operating systems.
Instance — The specific data allocated in an application that defines a particular object.
Interface — A set of related functions, types, constants, and variables. An interface is often specified via
a C header file.
Interrupt Latency — The maximum time between when an interrupt occurs and its corresponding
Interrupt Service Routine (ISR) starts executing.
Interrupt Service Routine (ISR) — An ISR is a function called in response to an interrupt detected by a
CPU.
Method — The term method is a synonym for a function that can be applied to an object defined by an
interface.
Module — A module is an implementation of one (or more) interfaces. In addition, all modules follow
certain design elements that are common to all standard-compliant software components. Roughly
speaking, a module is a C language implementation of a C++ class. Since a module is an
implementation of an interface, it may consist of many distinct object files.
Multithreading — Multithreading is the management of multiple concurrent uses of the same program.
Most operating systems and modern computer languages also support multithreading.
Preemptive — A property of a scheduler that allows one task to asynchronously interrupt the execution of
the currently executing task and switch to another task; the interrupted task is not required to call
any scheduler functions to enable the switch.
Protection Boundary — A protection boundary protects one software subsystem on a computer from
another, in such a way that only data that is explicitly shared across such a boundary is accessible
to the entities on both sides. In general, all code within a protection boundary will have access to all
data within that boundary.
The canonical example of a protection boundary on most modern systems is that between
processes and the kernel. The kernel is protected from processes, so that they can only examine or
change its internal state in certain strictly defined ways.
Protection boundaries also exist between individual processes on most modern systems. This
prevents one buggy or malicious process from wreaking havoc on others.
Why are protection boundaries interesting? Because transferring control across them is often
expensive; it takes a lot of time and work. Most DSPs have no support for protection boundaries.
Reentrant — Pertaining to a program or a part of a program in its executable version, that may be
entered repeatedly, or may be entered before previous executions have been completed, and each
execution of such a program is independent of all other executions.
Run to Completion — A thread execution model in which all threads run to completion without ever
synchronously suspending execution. Note that this attribute is completely independent of whether
threads are preemptively scheduled. Run to completion threads may be preempt on another (e.g.,
ISRs) and non-preemptive systems may allow threads to synchronously suspend execution. Note
that only one run-time stack is required for all run to completion threads in a system.
86 Glossary SPRU352G – June 2005 – Revised February 2007
Submit Documentation Feedback