Index
Prev   

Index

32-bit addressing
address size
Defining the Address Space
page size
Page Numbers and Offsets

64-bit addressing
address size
Defining the Address Space
page size
Page Numbers and Offsets

_ABI_SOURCE compiler variable
Two Implementation Versions

address range
Defining the Address Space

address space
Virtual Memory
Defining the Address Space
copy on write
Normal Process Creation With fork()
copy-on-write pages
Copy-on-Write Pages
defining addresses
Address Definition
duplicated by fork()
Normal Process Creation With fork()
functions that change
Isolating a CPU From TLB Interrupts
heap segment
Address Space Boundaries
interrogating
Interrogating the Memory System
limits of
Address Space Limits
lowest used address
Address Space Boundaries
of VME bus devices
VME Address Space Mapping
read-only pages
Read-Only Pages
replaced by exec()
Address Space Replacement With exec()
resident set size
Page Validation
shared by lightweight processes
Lightweight Process Creation With sproc()
stack segment
Address Space Boundaries
text segment
Address Space Boundaries
virtual size of
Address Definition

affinity scheduling
Understanding Affinity Scheduling
compared to static assignment
Assigning a Process to a Processor Set

affinity value
Understanding Affinity Scheduling

aio_cancel()
Scheduling Asynchronous I/O

aio_error()
Checking for Completion
Polling for Status
example code
Asynchronous I/O Example

aio_fsync()
Assuring Data Integrity

aio_read()
Scheduling Asynchronous I/O
example code
Asynchronous I/O Example
from callback
Establishing a Callback Function
implies aio_init()
Implicit Initialization

aio_return()
Checking for Completion
example code
Asynchronous I/O Example

aio_sgi_init()
Initializing with aio_sgi_init()
example code
Asynchronous I/O Example

aio_suspend()
Checking for Completion
example code
Asynchronous I/O Example

aio_write()
Scheduling Asynchronous I/O
example code
Asynchronous I/O Example
from callback
Establishing a Callback Function
implies aio_init()
Implicit Initialization

aircraft simulator
Aircraft Simulators

Application Binary Interface. See MIPS ABI
Two Implementation Versions

asynchronous I/O
Asynchronous I/O
Asynchronous I/O
Achieving High Transfer Rates to Disk
aiocb structure
Asynchronous I/O Control Block
Checking for Completion
difference between 5.3 and 5.2
Two Implementation Versions
example code
Asynchronous I/O Example
Asynchronous I/O Example
in IRIX 6.0
Two Implementation Versions
initializing
Initializing Asynchronous I/O
multiple operations to one file
Multiple Operations to One File
not compatible with guaranteed rate
Sharing Access to Guaranteed Files
notification methods
Checking for Completion
POSIX 1003.1b-1993
Two Implementation Versions
request priority no longer supported
Asynchronous I/O Control Block
signal use
Checking for Completion

average data rate
Requirements on Data Collection Systems

backing store
Address Definition
Page Validation

barrier
Barriers
starting Frame Scheduler
Synchronized Schedulers: Sync-Slave Processes

barrier()
Barriers
example code
Asynchronous I/O Example

batch priority
Setting a Nondegrading Batch Priority

brk()
Address Definition
modifies address space
Isolating a CPU From TLB Interrupts

bus
processor. See processor bus
CPUs, Memory, and the System Bus

bus,VME. See VME bus
VME Interrupts

cache
address mapping in Challenge/Onyx
Cache Mapping in Challenge/Onyx
affinity scheduling
Understanding Affinity Scheduling
architecture
Memory Hierarchy
effect of miss
Reducing Cache Misses
management
Reducing Cache Misses
multiprocessor conflicts
Multiprocessor Cache Conflicts
warming up in first frame
Process Execution

cache coherency
Cache Coherency Updates

cache line
Reducing Cache Misses

cacheflush()
Isolating a CPU From TLB Interrupts

CD-ROM audio library
CD-ROM and DAT Audio Libraries

Challenge/Onyx architecture
Multiprocessor Architecture
cache address mapping
Cache Mapping in Challenge/Onyx
cache management in
Reducing Cache Misses

clock_gettime()
Using POSIX clock_gettime()

concurrent execution
Concurrent Execution

copy on write page statue
Normal Process Creation With fork()

CPU
assign interrupt to
Assigning Interrupts to CPUs
assign process to
Assigning Work to a Restricted CPU
CPU 0 not used by Frame Scheduler
Frame Scheduler Basics
isolating from sprayed interrupts
Isolating a CPU From Sprayed Interrupts
isolating from TLB interrupts
Isolating a CPU From TLB Interrupts
making nonpreemptive
Making a CPU Nonpreemptive
relation to bus and memory
CPUs, Memory, and the System Bus
restricting to assigned processes
Restricting a CPU From Scheduled Work
Mapping Processes and CPUs

current directory
Process Composition

cycle counter
Hardware Cycle Counter
as Frame Scheduler time base
High-Resolution Timer
drift rate of
Using the Cycle Counter
Hardware Cycle Counter
example program
Reading the Cycle Counter
in interval timer management
Timer Management in Challenge, Onyx, and POWER-Challenge
mapping into memory
Using the Cycle Counter
precision of
Hardware Cycle Counter
Using the Cycle Counter
used for timestamp
Using the Cycle Counter

DAT audio library
CD-ROM and DAT Audio Libraries

data collection system
Data Collection Systems
Major Types of Real-Time Programs
average data rate
Requirements on Data Collection Systems
input rate
Achieving High Transfer Rates to Devices
peak data rate
Requirements on Data Collection Systems
requirements on
Requirements on Data Collection Systems

data segment
locking
Locking Program Text and Data

date command
Using POSIX clock_gettime()
Using BSD gettimeofday()

deadline scheduling
Deadline Scheduling
Using Deadline Scheduling

degrading priority
Special Scheduling Disciplines
Aging Priorities

/dev file system
How Devices Are Defined

/dev/ei
External Interrupts

device
defined in /dev
How Devices Are Defined
device numbers
How Devices Are Defined
opening
Other I/O
How Devices Are Used

device driver
Device Interrupts
Interrupt Response Time
as Frame Scheduler time base
The Frame Scheduler Device Driver Interface
entry points to
Device Driver Entry Points
for VME bus master
DMA Access to Master Devices
generic SCSI
Generic SCSI Device Driver
in synchronous input
Synchronous Input
reference pages
Device Driver Entry Points
tape
System Tape Device Driver

device interrupt
Device Interrupts

device service time
Components of Interrupt Response Time
Device Service Time
Interrupt Response Time
not guaranteed
Service Time for Other Devices

device special file
How Devices Are Defined

direct disk output
Using Direct I/O

disk output
synchronous direct
Using Direct I/O
synchronous unbuffered
Using Synchronous Writing

dispatch cycle time
Dispatch Cycle
Components of Interrupt Response Time

dlopen()
Isolating a CPU From TLB Interrupts

DMA engine for VME bus
DMA Engine Access to Slave Devices
performance
DMA Engine Access to Slave Devices

DMA mapping
DMA Mapping

DMA to VME bus master devices
DMA Access to Master Devices

drift rate of cycle counter
Using the Cycle Counter

dslib
Generic SCSI Device Driver

DSO
Isolating a CPU From TLB Interrupts

DSO, text segment for
Address Space Boundaries

dynamic shared object. See DSO
Isolating a CPU From TLB Interrupts

/etc/autoconfig command
Assigning Interrupts to CPUs

exec()
Address Space Replacement With exec()

external interrupt
External Interrupts
External Interrupts
with Frame Scheduler
External Interrupts

fasthz tuning parameter
Using Short Timer Intervals
effect of truncation
Selecting the fasthz Value

fcntl()
example code
Creating a Real-time File

file descriptor
of a device
How Devices Are Used
returned by open()
Other I/O
with asynchronous I/O
Asynchronous I/O Control Block
with guaranteed-rate I/O
Requesting a Guarantee

file, mapping into memory
Locking Mapped Files Into Memory

fork()
Normal Process Creation With fork()
defines address space
Address Definition
example
Normal Process Creation With fork()
new address space copy-on-write
Copy-on-Write Pages
rate guarantee not inherited
Sharing Access to Guaranteed Files

frame interval
Frame Rate

frame rate
Frame Rate
of plant control simulator
Plant Control Simulators
of virtual reality simulator
Virtual Reality Simulators

Frame Scheduler
REACT/Pro Frame Scheduler
Using the Frame Scheduler
advantages
Advantages of the Frame Scheduler
and cycle counter
High-Resolution Timer
and external interrupt
External Interrupts
and R4000 timer
On-Chip Timer Interrupt
and vertical sync
Vertical Sync Interrupt
background discipline
Background Discipline
continuable discipline
Continuable Discipline
CPU 0 not used by
Frame Scheduler Basics
definition of frame
How Frames Are Defined
design process
Designing With the Frame Scheduler
device driver initialization
Frame Scheduler Initialization Function
device driver interface
The Frame Scheduler Device Driver Interface
device driver interrupt
Generating Interrupts
device driver termination
Frame Scheduler Termination Function
device driver use
Device Driver Overview
example code
Frame Scheduler Examples
exception handling
Handling Frame Scheduler Exceptions
FRS control process
Using Multiple Synchronized Schedulers
The FRS Control Process
frs_run flag
Scheduler Flags frs_run and frs_yield
frs_yield flag
Scheduler Flags frs_run and frs_yield
interface to
The Frame Scheduler API
interval timers not used with
Using Timers with the Frame Scheduler
major frame
Frame Scheduling
minor frame
Frame Scheduling
multiple synchronized
Using Multiple Synchronized Schedulers
overrun exception
Exception Types
Realtime Discipline
overrunnable discipline
Overrunnable Discipline
pausing
Pausing Frame Schedulers
process outline for multiple
Implementing Synchronized Schedulers
process outline for single
Implementing a Single Frame Scheduler
process structure
Process Execution
realtime discipline
Realtime Discipline
scheduling disciplines
Using the Scheduling Disciplines
scheduling rules of
Scheduling Within a Minor Frame
signals produced by
Handling Signals in the FRS Controller
Setting Frame Scheduler Signals
software interrupt to
Software Interrupt
starting up
Starting Multiple Schedulers
time base selection
How Frames Are Defined
Selecting a Time Base
underrun exception
Realtime Discipline
Exception Types
underrunable discipline
Underrunable Discipline
using consecutive minor frames
Using Multiple Consecutive Minor Frames
warming up cache
Process Execution

FRS control process
Using Multiple Synchronized Schedulers
The FRS Control Process
design of
Implementing a Single Frame Scheduler
receives signals
Setting Frame Scheduler Signals

frs_create_master()
Exporting the Initialization and Termination Functions
Implementing a Single Frame Scheduler
Synchronized Schedulers: the Sync-Master Process

frs_create_slave()
Synchronized Schedulers: Sync-Slave Processes

frs_destroy()
Synchronized Schedulers: Sync-Slave Processes
Implementing a Single Frame Scheduler
Synchronized Schedulers: the Sync-Master Process

frs_driver_export()
Exporting the Initialization and Termination Functions

frs_enqueue()
Synchronized Schedulers: the Sync-Master Process
Scheduling Within a Minor Frame
Using the Scheduling Disciplines
Implementing a Single Frame Scheduler
Synchronized Schedulers: Sync-Slave Processes

frs_handle_driverintr()
Generating Interrupts

frs_join()
Starting Multiple Schedulers
Implementing a Single Frame Scheduler
Synchronized Schedulers: Sync-Slave Processes
Process Execution
Synchronized Schedulers: the Sync-Master Process

frs_resume()
Pausing Frame Schedulers

frs_setattr()
example code
Setting Exception Policies
Setting Exception Policies

frs_start()
Synchronized Schedulers: Sync-Slave Processes
Starting Multiple Schedulers
Synchronized Schedulers: the Sync-Master Process
Implementing a Single Frame Scheduler

frs_stop()
Pausing Frame Schedulers

frs_userinter()
Software Interrupt

frs_yield
Process Execution

frs_yield()
with overrunable discipline
Overrunnable Discipline

fsync()
Synchronous Output
Using Synchronous Writing

gang scheduling
Gang Scheduling
Using Gang Scheduling

getpagesize()
Interrogating the Memory System
Page Numbers and Offsets

getrlimit()
Address Space Limits

gettimeofday()
Using BSD gettimeofday()
Time of Day Timestamp
example code
Getting the Time of Day Stamp

GRIO. See guaranteed-rate I/O
Guaranteed-Rate I/O

grio_remove_request()
Releasing a Guarantee

grio_request()
Requesting a Guarantee
example code
Guaranteed-Rate Request

ground vehicle simulator
Ground Vehicle Simulators

group ID
Process Composition

guaranteed-rate I/O
Guaranteed-Rate I/O
Achieving High Transfer Rates to Disk
creating a real-time file
Creating a Real-time File
example code
Guaranteed-Rate Request
hard guarantee
Hard Guarantees
requesting a guarantee
Requesting a Guarantee
requires XFS
Guaranteed-Rate I/O Basics
requires XLV volume
Guaranteed-Rate I/O Basics
soft guarantee
Soft Guarantees
tied to PD and I-node
Sharing Access to Guaranteed Files
video on demand guarantee
Video On Demand (VOD) Guarantees

hardware latency
Components of Interrupt Response Time
Hardware Latency

hardware simulator
Hardware-in-the-loop (HITL) Simulators

heap segment
Address Space Boundaries
Address Definition

HZ value in timer management
Timer Management Without a Clock Comparator

inline functions and cache management
Locality of Reference

input
synchronous
Synchronous Input

interchassis communication
Interchassis Communication

interprocess communication
Interprocess Communication

interrupt
assign to CPU
Assigning Interrupts to CPUs
clock comparator
Timer Management in Challenge, Onyx, and POWER-Challenge
controlling distribution of
Controlling Interrupt Distribution
device
Device Interrupts
external. See external interrupt
External Interrupts
group. See interrupt group
Selecting a Time Base
isolating CPU from
Isolating a CPU From Sprayed Interrupts
latency
Interrupt Latency
periodic timer
Timer Management Without a Clock Comparator
propogation delay
Hardware Latency
response time. See interrupt response time
Minimizing Interrupt Response Time
spraying
VME Interrupts
Isolating a CPU From Sprayed Interrupts
TLB
Translation Lookaside Buffer Updates
Isolating a CPU From TLB Interrupts
validity fault
Page Validation
vertical sync
Understanding the Vertical Sync Interrupt
Vertical Sync Interrupt
VME bus
Hardware Latency
VME Interrupts

interrupt group
Selecting a Time Base
Frame Scheduler passes to device driver
Frame Scheduler Initialization Function
not used with cycle counter
High-Resolution Timer
to distribute external interrupt
External Interrupts
to distribute vertical sync
Vertical Sync Interrupt

interrupt response time
Interrupt Response Time
Minimizing Interrupt Response Time
200 microsecond guarantee
Maximum Response Time Guarantee
components
Components of Interrupt Response Time
device service not guaranteed
Service Time for Other Devices
device service time
Device Service Time
dispatch cycle
Dispatch Cycle
hardware latency
Hardware Latency
kernel service not guaranteed
Kernel Critical Sections
restrictions on processes
Kernel Critical Sections
software latency
Software Latency

interrupts
unavoidable from timer
Unavoidable Timer Interrupts

interval timer
Timer Interrupts (Itimers)
Using Interval Timers
cycle counter used to manage
Timer Management in Challenge, Onyx, and POWER-Challenge
example
Using an Itimer
management by kernel
How Timers Are Managed
not used with Frame Scheduler
Using Timers with the Frame Scheduler
BSD Itimers

ioctl()
and device driver
Device Driver Entry Points

IPL statement
Assigning Interrupts to CPUs

IRIS InSight
About This Guide

IRIX
kernel
CPUs, Memory, and the System Bus

IRIX overview
Basic Features of the CHALLENGE and IRIX™ Architectures

irix.sm configuration file
Assigning Interrupts to CPUs

itimer. See interval timer
Timer Interrupts (Itimers)

kernel
address space limits in
Address Space Limits
affinity scheduling
Understanding Affinity Scheduling
critical section
Kernel Critical Sections
deadline scheduling
Using Deadline Scheduling
degrading priority
Aging Priorities
gang scheduling
Using Gang Scheduling
interrupt response time
Software Latency
multiprocessor use
Concurrent Execution
CPUs, Memory, and the System Bus
optimizations in
Kernel Optimizations
originates signals
Signals
priority assignment
Priorities
process management
Process Composition
real-time features
Kernel Facilities for Real-Time Programs
scheduling
Scheduling Concepts
scheduling assumptions
Process Scheduling
scheduling queues
Scheduler Queues
tick
Tick Interrupts
time slice
Tick Interrupts
timer management
How Timers Are Managed

kernel address space
Defining the Address Space

latency
hardware
Hardware Latency
Components of Interrupt Response Time
software
Components of Interrupt Response Time
Software Latency

lightweight process
created with sproc()
Lightweight Process Creation With sproc()
less work to create
Lightweight Process Creation With sproc()
preferred for real-time use
Lightweight Process Creation With sproc()

limits command
Address Space Limits

linked lists and cache management
Locality of Reference

lio_listio()
Scheduling Asynchronous I/O

locality of reference
Memory Hierarchy
Locality of Reference

lock
Locks
defined
Locks
effect of gang scheduling
Using Gang Scheduling
metering
Locks
set by spinning
Locks
used by kernel
Concurrent Execution

locking virtual memory
Locking Virtual Memory

lseek()
with asynchronous I/O
Asynchronous I/O Control Block
with guaranteed-rate I/O
Video On Demand (VOD) Guarantees

major device number
How Devices Are Defined

major frame
Frame Scheduling

malloc()
Address Definition

MAP_AUTOGROW flag
Isolating a CPU From TLB Interrupts

MAP_LOCAL flag
Isolating a CPU From TLB Interrupts

memalign()
Locality of Reference

memory
Managing Virtual Memory in a Real–Time Program
address ranges of
Defining the Address Space
backing store for
Address Definition
hierarchy
Memory Hierarchy
interrogating size of
Interrogating the Memory System
locking pages in
Locking Pages in Memory
main
CPUs, Memory, and the System Bus
page
Page Numbers and Offsets
page size
Virtual Memory
shared. See shared memory
Shared Memory Segments
virtual
Virtual Memory

memory mapping
Address Definition
for I/O
Memory-Mapped I/O
locking mapped file
Locking Mapped Files Into Memory
of cycle counter
Using the Cycle Counter

metering lock use
Locks

metering semaphore use
IRIX Semaphores

minor device number
How Devices Are Defined

minor frame
Frame Scheduling
Scheduling Within a Minor Frame

MIPS ABI
asynchronous I/O
Two Implementation Versions

mmap()
Isolating a CPU From TLB Interrupts

mpadmin command
assign clock processor
Assigning the Clock Processor
make CPU nonpreemptive
Making a CPU Nonpreemptive
query fasthz CPU
Assigning the fasthz Processor
restrict CPU
Restricting a CPU From Scheduled Work
set fasthz CPU
Assigning the fasthz Processor
unrestrict CPU
Restricting a CPU From Scheduled Work

mpin()
Locking Mapped Files Into Memory
Locking Functions

mprotect()
Isolating a CPU From TLB Interrupts

multiprocessor architecture
CPUs, Memory, and the System Bus
affinity scheduling
Understanding Affinity Scheduling
and Frame Scheduler
Using Multiple Synchronized Schedulers

munmap()
Isolating a CPU From TLB Interrupts

munpin()
Locking Functions
Locking Mapped Files Into Memory

mutual exclusion primitive
Mutual Exclusion Primitives

NDPHIMAX constant
Priorities

NDPHIMIN constant
Priorities

ndpri_hilim tuning parameter
Setting a Nondegrading Batch Priority

ndpri_lolim tuning parameter
Setting a Nondegrading Real-Time Priority

newbarrier()
Barriers

“nice” value
Priorities

NOINTR statement
Isolating a CPU From Sprayed Interrupts

nondegrading batch priority
Setting a Nondegrading Batch Priority

nondegrading priorities
Nondegrading Priorities

nondegrading real-time priority
Setting a Nondegrading Real-Time Priority

npri command
Setting a Nondegrading Batch Priority
deadline scheduling
Using Deadline Scheduling
nondegrading priority
Setting a Nondegrading Real-Time Priority

open()
Other I/O
example code
Creating a Real-time File
of a device
How Devices Are Used

operator
affected by transport delay
Transport Delay
in virtual reality simulator
Virtual Reality Simulators
of simulator
Simulators

output
synchronous
Synchronous Output
to disk is buffered
Using Synchronous Writing

overrun in data collection system
Requirements on Data Collection Systems

overrun in Frame Scheduler
Realtime Discipline

page
copy on write
Copy-on-Write Pages
locking
Locking Pages in Memory
read-only
Read-Only Pages

page fault
Virtual Memory
causes TLB interrupt
Isolating a CPU From TLB Interrupts
prevent by locking memory
Locking Virtual Memory
Locking Pages in Memory

page size
Virtual Memory
Page Numbers and Offsets

page validation
Page Validation

peak data rate
Requirements on Data Collection Systems

performance effects of cache
Reducing Cache Misses

performance tools
Detecting Cache Problems

PIO access to VME devices
PIO Access

PIO address mapping
PIO Address Space Mapping

pixie command
Detecting Cache Problems

plant control simulator
Plant Control Simulators

plock()
Locking Functions
example of
Locking Program Text and Data

poll()
IRIX Semaphores

power plant simulator
Plant Control Simulators

prctl()
Interrogating the Memory System

priority
Priorities
degrading
Special Scheduling Disciplines
Aging Priorities
looping process can halt system
Setting a Nondegrading Real-Time Priority
nondegrading
Nondegrading Priorities
nondegrading batch
Setting a Nondegrading Batch Priority
nondegrading real-time
Setting a Nondegrading Real-Time Priority
ranges of
Priorities

process
Process Management
”nice” value
Priorities
address space
Address Space Boundaries
assign to CPU
Assigning Work to a Restricted CPU
assigned to processor
Assigning a Process to a Processor Set
attributes
Process Composition
attributes initialized by exec()
Address Space Replacement With exec()
blocked by I/O
I/O Scheduling
composition
Process Composition
created with fork()
Normal Process Creation With fork()
FRS control
The FRS Control Process
lightweight. See lightweight process
Lightweight Process Creation With sproc()
mapping to CPU
Mapping Processes and CPUs
priority of
Priorities
time slice
Time Slices

process control
Major Types of Real-Time Programs

process creation
Process Creation

process group
Gang Scheduling
and gang scheduling
Using Gang Scheduling

process ID
Process Composition
identifies rate guarantee
Sharing Access to Guaranteed Files

process scheduling
Process Scheduling

processor bus
capacity
CPUs, Memory, and the System Bus
diagram
Multiprocessor Architecture

processor set
Processor Sets
Using Processor Sets
contradiction
Processor Set Contradictions

prof command
Detecting Cache Problems

propogation delay. See hardware latency
Hardware Latency

ps command
Address Definition

pscommand
Page Validation

pset command
Using Processor Sets
Scheduler Queues
and restricted CPU
Restricting a CPU From Scheduled Work
contradictions
Processor Set Contradictions

punlock()
Locking Functions

queue, scheduling
Priorities
Scheduler Queues

R4000 timer
On-Chip Timer Interrupt

REACT
About This Guide

REACT/Pro
About This Guide

read()
and device driver
Device Driver Entry Points
synchronous
Synchronous Input
with guaranteed-rate I/O
Requesting a Guarantee

real-time priority
Setting a Nondegrading Real-Time Priority

real-time program
and Frame Scheduler
REACT/Pro Frame Scheduler
and scheduler assumptions
Process Scheduling
data collection
Major Types of Real-Time Programs
Data Collection Systems
defined
Defining Real-Time Programs
disk I/O by
Optimizing Disk I/O for a Real-Time Program
frame rate
Requirements on Simulators
lightweight processes preferred
Lightweight Process Creation With sproc()
process control
Major Types of Real-Time Programs
simulator
Simulators
Major Types of Real-Time Programs
types of
Real-Time Programs

reflective shared memory
Reflective Shared Memory

resident set size
Page Validation

response time. See interrupt response time
Minimizing Interrupt Response Time

restricting a CPU
Restricting a CPU From Scheduled Work

rlimit kernel parameter
Address Space Limits

rtnetd daemon, priority of
Setting a Nondegrading Real-Time Priority

runon command
Assigning Work to a Restricted CPU

schedctl()
Assigning Work to a Restricted CPU
Setting a Nondegrading Real-Time Priority
Setting a Nondegrading Batch Priority
Using Deadline Scheduling
Using Gang Scheduling
example code
Setting a Nondegrading Batch Priority
Setting a Nondegrading Real-Time Priority
Deadline Scheduling Subroutines
Using Gang Scheduling
with Frame Scheduler
System Call Interface for Fortran and Ada

scheduling
Scheduling Concepts
affinity type
Understanding Affinity Scheduling
assumptions
Process Scheduling
deadline type
Deadline Scheduling
Using Deadline Scheduling
degrading priority
Special Scheduling Disciplines
gang type
Using Gang Scheduling
Gang Scheduling
nondegrading priority
Nondegrading Priorities

scheduling discipline
Assigning a Discipline to a Processor Set
ZZZ
Using the Scheduling Disciplines

scheduling queue
Priorities
Scheduler Queues
processor set assigned to
Assigning a Processor Set to a Queue

SCSI interface
SCSI Devices
generic device driver
Generic SCSI Device Driver

segment
heap
Address Space Boundaries
locking
Locking Program Text and Data
lowest address
Address Space Boundaries
stack
Address Space Boundaries
text
Address Space Boundaries

semaphore
Semaphores
defined
Semaphores
IRIX implementation
IRIX Semaphores
metering
IRIX Semaphores
pollable
IRIX Semaphores
portable implementation
SVR4-Compatible Semaphores
used by kernel
Concurrent Execution
used with interval timer
Using an Itimer

semget()
SVR4-Compatible Semaphores

semop()
SVR4-Compatible Semaphores

setitimer()
BSD Timer Support
Timer Interrupts (Itimers)

setitimer()example code
Using an Itimer

setrlimit()
Address Space Limits

sginap()
Locks
example code
Asynchronous I/O Example

shared memory
Shared Memory Segments
IRIX implementation
IRIX Shared Memory Arenas
portable implementation
SVR4-Compatible Shared Memory
reflective
Reflective Shared Memory
usconfig()
IRIX Shared Memory Arenas
usinit()
IRIX Shared Memory Arenas

shmat()
SVR4-Compatible Shared Memory

shmctl()
SVR4-Compatible Shared Memory
Isolating a CPU From TLB Interrupts

shmget()
Isolating a CPU From TLB Interrupts
SVR4-Compatible Shared Memory

sigaction()
example code
Asynchronous I/O Example
Using an Itimer
with asynchronous I/O
Establishing a Completion Signal

SIGALRM
from interval timer
BSD Timer Support
BSD Itimers

SIGBUS
on reference to undefined page
Address Definition

sigevent structure
Asynchronous I/O Control Block

SIGKILL
possible when locking pages
Locking Functions

signal
Signals
delivery priority
Signals
generated from interval timer
BSD Timer Support
generated in asynchronous I/O
Checking for Completion
latency
Signal Delivery and Latency
SIGALRM
BSD Itimers
BSD Timer Support
SIGBUS
Address Definition
SIGKILL
Locking Functions
signal numbers
Signals
SIGSEGV
Read-Only Pages
SIGUSR1
Setting Frame Scheduler Signals
SIGUSR2
Setting Frame Scheduler Signals
with Frame Scheduler
Using Signals Under the Frame Scheduler

signal handler
as process attribute
Process Composition
when setting up Frame Scheduler
Implementing a Single Frame Scheduler
Synchronized Schedulers: the Sync-Master Process
Synchronized Schedulers: Sync-Slave Processes

SIGRTMIN on dequeue
Setting Frame Scheduler Signals

SIGSEGV
on attempt to change read-only page
Read-Only Pages

sigsuspend()
Checking for Completion

SIGUSR1
on underrun
Setting Frame Scheduler Signals

SIGUSR2
on overrun
Setting Frame Scheduler Signals

sigwait()
Checking for Completion

simulator
Major Types of Real-Time Programs
Simulators
aircraft
Aircraft Simulators
control inputs to
Plant Control Simulators
Simulators
frame rate of
Requirements on Simulators
Plant Control Simulators
ground vehicle
Ground Vehicle Simulators
hardware
Hardware-in-the-loop (HITL) Simulators
operator of
Simulators
plant control
Plant Control Simulators
state display
Simulators
virtual reality
Virtual Reality Simulators
world model in
Simulators

sockets
Socket Programming

software latency
Components of Interrupt Response Time
Software Latency

spin lock
Locks

sproc()
Lightweight Process Creation With sproc()
CPU assignment inherited
Assigning Work to a Restricted CPU
modifies address space
Isolating a CPU From TLB Interrupts
rate guarantee not inherited
Sharing Access to Guaranteed Files

sprocsp()
Isolating a CPU From TLB Interrupts
example code
Asynchronous I/O Example

stack segment
Address Space Boundaries
Address Definition
locking
Locking Program Text and Data

striped volume
Video On Demand (VOD) Guarantees

structures and cache management
Locality of Reference

swap
Address Definition
Page Validation

swapctl()
Interrogating the Memory System

synchronous disk output
Using Synchronous Writing

sys/param.h
Tick Interrupts

sys/schedctl.h
Priorities

sysconf()
Interrogating the Memory System

sysmp()
Assigning Work to a Restricted CPU
Interrogating the Memory System
assign process to CPU
Assigning Work to a Restricted CPU
example code
Assigning the Clock Processor
Restricting a CPU From Scheduled Work
Assigning the fasthz Processor
Assigning Work to a Restricted CPU
Making a CPU Nonpreemptive
Restricting a CPU From Scheduled Work
isolate TLB interrupts
Isolating a CPU From TLB Interrupts
make CPU nonpreemptive
Making a CPU Nonpreemptive
number of CPUs
Restricting a CPU From Scheduled Work
restrict CPU
Restricting a CPU From Scheduled Work
Restricting a CPU From Scheduled Work
run process on any CPU
Assigning Work to a Restricted CPU
set fasthz CPU
Assigning the fasthz Processor

syssgi
set flush interval
Using a Delayed System Buffer Flush

syssgi()
Interrogating the Memory System
Using the Cycle Counter

systune command
Address Space Limits
Fast Timers Without a Clock Comparator

tape device
System Tape Device Driver

telemetry
Major Types of Real-Time Programs

test_and_set
Mutual Exclusion Primitives

text segment
Address Space Boundaries
loaded from program file
Page Validation
locking
Locking Program Text and Data
read-only
Read-Only Pages

tick
Tick Interrupts
disabling
Making a CPU Nonpreemptive

time base for Frame Scheduler
Selecting a Time Base

time slice
Tick Interrupts

timer interrupts unavoidable
Unavoidable Timer Interrupts

timer management
How Timers Are Managed

timestamp
Timestamps
Using Timestamps
comparing methods
Comparing the Timestamps
from clock_gettime()
Using POSIX clock_gettime()
from cycle counter
Using the Cycle Counter
from gettimeofday()
Using BSD gettimeofday()

TLB
Translation Lookaside Buffer Updates

TLB update interrupt
Translation Lookaside Buffer Updates
Isolating a CPU From TLB Interrupts

translation lookaside buffer. See TLB
Translation Lookaside Buffer Updates

transport delay
Transport Delay

udmalib
DMA Engine Access to Slave Devices

underrun, in Frame Scheduler
Realtime Discipline

usconfig()
IRIX Shared Memory Arenas

user ID
Process Composition

usinit()
IRIX Shared Memory Arenas
arena for barrier
Barriers
arena for lock
Locks
arena for semaphore
IRIX Semaphores

usnewlock()
Locks

usnewsema()
IRIX Semaphores

uspsema
IRIX Semaphores

uspsema()
example code
Asynchronous I/O Example

ussetlock()
Locks

usunsetlock()
Locks

usvsema
IRIX Semaphores

usvsema()
example code
Asynchronous I/O Example
Using an Itimer

validity fault
Page Validation

vertical sync interrupt
Understanding the Vertical Sync Interrupt
Vertical Sync Interrupt

video on demand (VOD). See guaranteed-rate I/O, video on demand
Video On Demand (VOD) Guarantees

virtual address space. See address space
Defining the Address Space

virtual memory
Virtual Memory
loading pages
Page Validation
locking
Locking Virtual Memory
page fault
Virtual Memory
ZZZ
Managing Virtual Memory in a Real–Time Program

virtual page number
Page Numbers and Offsets

virtual reality simulator
Virtual Reality Simulators

virtual size
Address Definition

VME bus
The VME Bus
address space mapping
VME Address Space Mapping
and process scheduling
VME Bus I/O
assign interrupt to CPU
Assigning Interrupts to CPUs
configuration
VME Bus Attachments
data input rate
Achieving High Transfer Rates to Devices
DMA mapping
DMA Mapping
DMA to master devices
DMA Access to Master Devices
hardware latency of
Hardware Latency
interrupt levels
VME Interrupts
performance
DMA Engine Access to Slave Devices
DMA Access to Master Devices
PIO Access
PIO access
PIO Access
PIO address mapping
PIO Address Space Mapping
udmalib
DMA Engine Access to Slave Devices

VPN. See virtual page number
Page Numbers and Offsets

write()
and device driver
Device Driver Entry Points
direct
Using Direct I/O
synchronous
Using Synchronous Writing
Synchronous Output
with guaranteed-rate I/O
Requesting a Guarantee
Creating a Real-time File

Prev Table of Contents 
Glossary