Index
Prev
Index
_GNU_SOURCE
Exclusively Accessing a Device
abstraction layer
Abstraction Layer
access to select REACT features
Specifying Permissions
activity thread management
Managing Activity Threads
address space (locking in memory)
Locking the Program Address Space
aircraft simulator
Aircraft Simulators
allowed capabilities REACT library routine
cpu_sysrt_set_allowed_caps
API
REACT library
Using the REACT Library
API example
libreact
API Example
asynchronous I/O
Asynchronous I/O
average data rate
Data Collection Systems
BOARD_ID
External Interrupt Output for the PCIE-RT Card
BOARD_VERSION
External Interrupt Output for the PCIE-RT Card
/boot
react
Command Overview
/boot cpuset
Using the REACT Library
cpu_sysrt_info
BOOTCPUS
cpu_sysrt_info
bootcpuset
Controlling Kernel and User Threads
react
Command Overview
/boot/grub/menu.lst
react
Command-Line Syntax
BOOTMEMS
cpu_sysrt_info
C language
REACT Requirements
cache warming
Thread Execution
callout deregistration
Callout Deregistration
callout mechanism
Callout Mechanism
callout registration
Callout Registration
CAP_DAC_OVERRIDE authority
Specifying Permissions
cap_ipc_lock
Installing the
pam_capability
Package
cap_sys_nice
Installing the
pam_capability
Package
capabilities REACT library routine
cpu_sysrt_set_caps
cat
Diagnostic Tools
character special device and class
Low-level Driver Template
clock processor
Avoid the Clock Processor (CPU 0)
clock source
Determining the Clock Source
clock_gettime()
Real-Time Clocks
Real-Time Clocks
Direct RTC Access
CLOCK_MONOTONIC
Real-Time Clocks
CLOCK_REALTIME
Real-Time Clocks
clock_settime
Real-Time Clocks
clocks
Real-Time Clocks
clocksource
Determining the Clock Source
command execution on a real-time CPU
Executing Commands on a Real-Time CPU
configuration
REACT System Configuration
configuration changes
Changing the Configuration
configuration display
Showing the Configuration
console interrupts
Interrupt Distribution Control
control law process stimulator
Control Law Processor Stimulator
controller thread
Synchronizing Multiple Schedulers
Implementing a Single Frame Scheduler
core ID
Diagnostic Tools
cores requirement
REACT Requirements
CPU
restricting
Processes Mapping and CPUs
Restricting a CPU from Scheduled Work and Isolating it from Scheduler Load Balancing
workload control
CPU Workload
CPU 0
Avoid the Clock Processor (CPU 0)
CPU affinity routine
cpu_sysrt_irq
CPU designation routine
cpu_sysrt_runon
CPU specification
react
Command-Line Syntax
cpu_shield
cpu_shield
cpu_sysrt_add
cpu_sysrt_add
cpu_sysrt_delete
cpu_sysrt_delete
cpu_sysrt_info
cpu_sysrt_info
cpu_sysrt_irq
cpu_sysrt_irq
cpu_sysrt_move
cpu_sysrt_move
cpu_sysrt_perm
cpu_sysrt_perm
cpu_sysrt_runon
cpu_sysrt_runon
cpu_sysrt_set_allowed_caps
cpu_sysrt_set_allowed_caps
cpu_sysrt_set_caps
cpu_sysrt_set_caps
CPU-bound
Special Scheduling Disciplines
CPUs in the /boot cpuset
cpu_sysrt_info
cpuset
Controlling Kernel and User Threads
Running a Process on a Real-Time CPU
cpusets
Frame Scheduler Basics
cpuset-utils
REACT RPMs
CPU-to-core numbering scheme
Diagnostic Tools
create real-time routine
cpu_sysrt_add
cycles per second
Simulators and Stimulators
data collection system
Data Collection Systems
debug kernel
REACT
™
Features
delay mode
PCIE-RT card
External Interrupt Output for the PCIE-RT Card
delete real-time routine
cpu_sysrt_delete
deregistration of callout
Callout Deregistration
dev attribute file
sysfs
Attribute Files
/dev/extint#
Opening the Device Special File
device service time
Device Service
Components of Interrupt Response Time
device special file
Opening the Device Special File
device-driver time base
Frame Scheduler Basics
diagnostic tools
Diagnostic Tools
direct RTC access
Direct RTC Access
disable REACT
react
Command-Line Syntax
disabling REACT
Disabling REACT
disciplines
Special Scheduling Disciplines
disk I/O optimization
Disk I/O Optimization
distributed applications
Message-Passing Interface (MPI)
dplace
Running a Process on a Real-Time CPU
driver deregistration
Driver Deregistration
driver interface
Low-Level Driver Interface
driver registration
Driver Registration
driver template
Low-level Driver Template
earnings-based scheduler
Special Scheduling Disciplines
enable a REACT configuration
react
Command-Line Syntax
/etc/elilo.conf
react
Command-Line Syntax
/etc/pam.d/sshd
Installing the
pam_capability
Package
/etc/react.conf
react
Command Overview
/etc/security/capability.conf
Installing the
pam_capability
Package
/etc/sysconfig/sgi-react.conf
Specifying Permissions
/etc/udev/rules.d/99-sgi-react.rules
Specifying Permissions
eternal interrupt ingest
PCIE-RT
External Interrupt Ingest for the PCIE-RT Card
examples
API code
REACT library
Example Code Using the REACT Library Routines
exception types
Exception Types
EXTERNAL
External Interrupt Output for the PCIE-RT Card
external interrupt abstraction layer
Abstraction Layer
external interrupt with frame scheduler
External Interrupts as a Time Base
external interrupts
External Interrupts
EXTERNAL_OVR
External Interrupt Output for the PCIE-RT Card
extint
REACT RPMs
sysfs
Attribute Files
Opening the Device Special File
extint_device
Low-Level Driver Interface
extint_properties
Low-Level Driver Interface
fastcall
Real-Time Clocks
features
REACT
™
Features
feedback loop
Simulators and Stimulators
firm real-time program
Real-Time Programs
first-in-first-out
Special Scheduling Disciplines
flock system call
Exclusively Accessing a Device
fork()
Implementing a Single Frame Scheduler
frame interval
Simulators and Stimulators
frame rate
Simulators and Stimulators
frame scheduler
REACT
™
Features
Using the Frame Scheduler
advantages
Frame Scheduler
API
Frame Scheduler API
background discipline
Background Discipline
basics
Frame Scheduler Basics
concepts
Frame Scheduler Concepts
continuable discipline
Continuable Discipline
controller thread
Synchronizing Multiple Schedulers
current frame extension
Extending the Current Frame
design process
Designing an Application for the Frame Scheduler
exception counts
Querying Counts of Exceptions
exception handling
Handling Frame Scheduler Exceptions
exception policies
Setting Exception Policies
exception types
Exception Types
external interrupt
External Interrupts as a Time Base
frame scheduler controller
Controller Thread
frs_run flag
Scheduler Flags
frs_run
and
frs_yield
frs_yield flag
Scheduler Flags
frs_run
and
frs_yield
high-resolution timer
High-Resolution Timer
interval timers not used with
Using Timers with the Frame Scheduler
library interface for C programs
Library Interface for C Programs
major frame
Frame Scheduling
managing activity threads
Managing Activity Threads
minor frame
Frame Scheduling
multiple exceptions
Dealing With Multiple Exceptions
multiple synchronized
Synchronizing Multiple Schedulers
overrun exception
Real-Time Discipline
Exception Types
overrunnable discipline
Overrunnable Discipline
overview
Frame Scheduler
pausing
Pausing Frame Schedulers
preparing the system
Preparing the System
process outline for single
Implementing a Single Frame Scheduler
real-time discipline
Real-Time Discipline
repeat frame
Injecting a Repeat Frame
scheduling disciplines
Using the Scheduling Disciplines
scheduling rules of
Scheduling Within a Minor Frame
sequence error handling
Handling a Sequence Error
signal use under
Using Signals Under the Frame Scheduler
signals in an activity thread
Handling Signals in an Activity Thread
signals produced by
Handling Signals in the Frame Scheduler Controller
Setting Frame Scheduler Signals
starting up a single scheduler
Starting a Single Scheduler
starting up multiple schedulers
Starting Multiple Schedulers
synchronized schedulers
Implementing Synchronized Schedulers
thread programming model
Thread Programming Model
thread structure
Thread Execution
time base selection
Frame Scheduling
Selecting a Time Base
underrun exception
Real-Time Discipline
Exception Types
underrunable discipline
Underrunable Discipline
using consecutive minor frames
Using Multiple Consecutive Minor Frames
warming up cache
Thread Execution
frame scheduler controller
Controller Thread
receives signals
Setting Frame Scheduler Signals
FREQUENCY
External Interrupt Output for the PCIE-RT Card
frs
See
frame scheduler
frs_create()
Library Interface for C Programs
Implementing a Single Frame Scheduler
frs_create_master()
Library Interface for C Programs
Implementing a Single Frame Scheduler
Master Controller Thread
frs_create_slave()
Library Interface for C Programs
Slave Controller Thread
frs_create_vmaster()
Library Interface for C Programs
Implementing a Single Frame Scheduler
Master Controller Thread
frs_destroy()
Library Interface for C Programs
Implementing a Single Frame Scheduler
Master Controller Thread
Slave Controller Thread
frs_enqueue()
Library Interface for C Programs
Starting Multiple Schedulers
Implementing a Single Frame Scheduler
frs_fsched_info_t
Frame Scheduler API
frs_getattr()
Library Interface for C Programs
Querying Counts of Exceptions
frs_getqueuelen()
Library Interface for C Programs
Managing Activity Threads
frs_intr_info_t
Frame Scheduler API
Interrupt Information Templates
frs_join
Library Interface for C Programs
frs_join()
Thread Execution
Starting Multiple Schedulers
Implementing a Single Frame Scheduler
Master Controller Thread
Slave Controller Thread
frs_overrun_info_t()
Querying Counts of Exceptions
frs_pinsert()
Library Interface for C Programs
Managing Activity Threads
frs_premove()
Library Interface for C Programs
Managing Activity Threads
Handling Signals in an Activity Thread
frs_pthread_enqueue()
Library Interface for C Programs
Scheduling Within a Minor Frame
Using the Scheduling Disciplines
Implementing a Single Frame Scheduler
Master Controller Thread
Slave Controller Thread
frs_pthread_getattr()
Library Interface for C Programs
Querying Counts of Exceptions
frs_pthread_insert
Library Interface for C Programs
frs_pthread_insert()
Managing Activity Threads
frs_pthread_readqueue()
Library Interface for C Programs
Managing Activity Threads
frs_pthread_register()
Library Interface for C Programs
frs_pthread_remove()
Library Interface for C Programs
Managing Activity Threads
Handling Signals in an Activity Thread
frs_pthread_setattr()
Library Interface for C Programs
Setting Exception Policies
example code
Setting Exception Policies
Setting Exception Policies
frs_queue_info_t
Frame Scheduler API
frs_readqueue()
Library Interface for C Programs
Managing Activity Threads
frs_recv_info_t
Frame Scheduler API
frs_resume()
Library Interface for C Programs
Pausing Frame Schedulers
frs_run
Detecting Overrun and Underrun
frs_setattr()
Library Interface for C Programs
Setting Exception Policies
frs_start
Library Interface for C Programs
frs_start()
Starting Multiple Schedulers
Implementing a Single Frame Scheduler
Master Controller Thread
Slave Controller Thread
frs_stop
Library Interface for C Programs
frs_stop()
Pausing Frame Schedulers
frs_t
Frame Scheduler API
frs_userintr()
Library Interface for C Programs
frs_yield
Library Interface for C Programs
Thread Execution
Detecting Overrun and Underrun
Overrunnable Discipline
fsync
Conventional Synchronous I/O
generating a REACT system configuration
REACT System Configuration
global variables and ULI
Planning for Concurrency: Declaring Global Variables
ground vehicle simulator
Ground Vehicle Simulators
hard real-time program
Real-Time Programs
hardware latency
Components of Interrupt Response Time
Hardware Latency
hardware-in-the-loop simulator
Hardware-in-the-Loop Simulators
high mode
PCIE-RT card
External Interrupt Output for the PCIE-RT Card
high-resolution timer
High-Resolution Timer
High-Resolution Timer Example
hyperthreading
Diagnostic Tools
Hz (hertz, cycles per second)
Simulators and Stimulators
implementation functions
Implementation Functions
include files
Accessing REACT Library Routines
INGEST_CTRL
External Interrupt Output for the PCIE-RT Card
INGEST_EN
External Interrupt Output for the PCIE-RT Card
INGEST_STATUS
External Interrupt Output for the PCIE-RT Card
inheritable capability enabling
Installing the
pam_capability
Package
initial configuration
Initially Configuring REACT
interchassis communication
Interchassis Communication
internal driver circuit I/O connectors
Physical Interfaces for the PCIE-RT Card
interrupt
group. See interrupt group
Selecting a Time Base
See also user-level interrupt (ULI)
ULI Functional Overview
interrupt abstraction layer
Abstraction Layer
interrupt control
Interrupt Distribution Control
interrupt group
Selecting a Time Base
interrupt information template
Interrupt Information Templates
interrupt notification interface
Interrupt Notification Interface
interrupt propagation delay
Hardware Latency
interrupt redirection
Redirect Interrupts
interrupt response time
components
Components of Interrupt Response Time
definition of
Understanding Interrupt Response Time
minimizing
Minimizing Interrupt Response Time
interrupt service routines (ISRs)
Interrupt Service Routines
ULI Functional Overview
interval
See
frame interval
interval timer
Using Timers with the Frame Scheduler
introduction
Introduction
invoke a subcommand
react
Command-Line Syntax
I/O interrupts
Interrupt Distribution Control
I/O-bound
Special Scheduling Disciplines
IRQ redirection
Using the REACT Library
IRQ specification
react
Command-Line Syntax
kernel arguments specification
react
Command-Line Syntax
kernel command-line options
Changing Specific Kernel Command-Line Options
kernel critical section
Kernel Critical Sections
kernel facilities for real-time
Kernel Facilities
kernel module insertion/removal
Avoid Kernel Module Insertion and Removal
kernel scheduling
Scheduling Concepts
kernel thread control
Controlling Kernel and User Threads
latency
Components of Interrupt Response Time
Hardware Latency
libbitmask
REACT RPMs
libcpuset
REACT RPMs
Running a Process on a Real-Time CPU
libreact
REACT RPMs
libreact API example
libreact
API Example
libuli
ULI Functional Overview
linkage
Accessing REACT Library Routines
Linux requirement
REACT Requirements
Linux Trace Toolkit Next Generation
See
LTTng
lk
REACT RPMs
LOCK_MAND
Exclusively Accessing a Device
locking memory
Locking the Program Address Space
locking virtual memory
Virtual Memory Locking
LOGIC_MAJOR
External Interrupt Output for the PCIE-RT Card
LOGIC_MINOR
External Interrupt Output for the PCIE-RT Card
low mode
PCIE-RT card
External Interrupt Output for the PCIE-RT Card
low-level driver interface
Low-Level Driver Interface
low-level driver template
Low-level Driver Template
lspci
PCI Devices
LTTng
overview
SLES LTTng
SLES
documentation
LTTng Documentation for SLES
installing
Installing LTTng on SLES
major frame
Frame Scheduling
master controller thread
Master Controller Thread
master scheduler
Synchronized Scheduler Concepts
maximum response time guarantee
Maximum Response Time Guarantee
mechanism for callout
Callout Mechanism
memory locking (virtual)
Virtual Memory Locking
memory nodes assigned to the /boot cpuset
cpu_sysrt_info
memory requirement
REACT Requirements
memory-mapped I/O
Memory-Mapped I/O
Message-Passing Interface (MPI)
Message-Passing Interface (MPI)
minor frame
Frame Scheduling
Scheduling Within a Minor Frame
mlock()
Virtual Memory Locking
Restrictions on the ULI Handler
mlockall()
Virtual Memory Locking
Restrictions on the ULI Handler
mmap
Counting Interrupts
mode attribute file
sysfs
Attribute Files
mode switch
Mode Switch
Components of Interrupt Response Time
modelist attribute file
sysfs
Attribute Files
modes for PCIE-RT cart
External Interrupt Output for the PCIE-RT Card
move routine
cpu_sysrt_move
MPI
Message-Passing Interface (MPI)
ms (milliseconds)
Simulators and Stimulators
msync
Memory-Mapped I/O
Conventional Synchronous I/O
multiple devices and ULI
Using Multiple Devices
multiprocessor architecture
Synchronizing Multiple Schedulers
new pthreads library (NPTL)
Setting Pthread Priority
nice value
Special Scheduling Disciplines
normal-time program
Real-Time Programs
NPTL
Setting Pthread Priority
oneshot mode
PCIE-RT card
External Interrupt Output for the PCIE-RT Card
operating system requirements
REACT Requirements
operator
Simulators and Stimulators
overhead work
Minimizing Overhead Work
overrun
Data Collection Systems
overrun exception
Detecting Overrun and Underrun
overrun in frame scheduler
Real-Time Discipline
ownership specification
react
Command-Line Syntax
page fault
Virtual Memory Locking
pam_capability
cpu_sysrt_set_caps
Installing the
pam_capability
Package
param.h
Timer Interrupts
PCI devices and programmed I/O
PCI Devices
pcie_extint
Opening the Device Special File
pcie_rt
Overview of the PCIE-RT Card
PCIE-RT card
External Interrupts
External Interrupts
Example: SGI PCIE-RT Real-Time Interrupt Card
external interrupt ingest
External Interrupt Ingest for the PCIE-RT Card
modes
External Interrupt Output for the PCIE-RT Card
physical interfaces
Physical Interfaces for the PCIE-RT Card
register format
External Interrupt Output for the PCIE-RT Card
peak data rate
Data Collection Systems
period attribute
External Interrupt Output for the PCIE-RT Card
period attribute file
sysfs
Attribute Files
permissions
Specifying Permissions
permissions routine
cpu_sysrt_perm
permissions specification
react
Command-Line Syntax
physical ID
Diagnostic Tools
physical interfaces
PCIE-RT
Physical Interfaces for the PCIE-RT Card
physical memory requirements
Virtual Memory Locking
poll
Waiting for Interrupts
POSIX
real-time policies
Special Scheduling Disciplines
real-time specification 1003.1-2003
Asynchronous I/O Basics
power plant simulator
Plant Control Simulators
priorities
Using Priorities and Scheduling Queues
priority band
Real-Time Priority Band
problem removing /rtcpus
Problem Removing
/rtcpus
/proc manipulation
Interrupt Distribution Control
/proc/cpuinfo
Diagnostic Tools
process control
Process Control Systems
process mapping to CPU
Processes Mapping and CPUs
process running on a real-time CPU
Running a Process on a Real-Time CPU
processor requirement
REACT Requirements
/proc/interrupts
Redirect Interrupts
Diagnostic Tools
profile.pl
Diagnostic Tools
programmed I/O and PCI devices
PCI Devices
programming language for REACT
REACT Requirements
propagation delay
Hardware Latency
ps
Real-Time Priority Band
Diagnostic Tools
pthread priority
Setting Pthread Priority
pthread_attr_setinheritsched()
Setting Pthread Priority
pthread_attr_setschedparam()
Setting Pthread Priority
pthread_attr_setschedpolicy()
Setting Pthread Priority
pthread_attr_t
Setting Pthread Priority
pthread_attr_t()
Frame Scheduler API
pthread_create()
Setting Pthread Priority
Implementing a Single Frame Scheduler
PTHREAD_EXPLICIT_SCHED
Setting Pthread Priority
PTHREAD_INHERIT_SCHED
Setting Pthread Priority
pthread_setschedparam()
Setting Pthread Priority
pthread_t
Frame Scheduler API
pulse mode
PCIE-RT card
External Interrupt Output for the PCIE-RT Card
quantum attribute
External Interrupt Output for the PCIE-RT Card
quantum attribute file
sysfs
Attribute Files
rate
See
frame rate
react command
REACT
™
Features
kernel specification
react
Command-Line Syntax
permissions
react
Command-Line Syntax
real-time CPU specification
react
Command-Line Syntax
synopsis
react
Command Overview
react-utils
REACT RPMs
read system call
Counting Interrupts
real-time applications
Real-Time Applications
real-time clock (RTC)
Real-Time Clocks
real-time CPU and running a process
Running a Process on a Real-Time CPU
real-time CPU specification
react
Command-Line Syntax
real-time CPUs currently configured on the system
cpu_sysrt_info
real-time memory nodes associated with the real-time CPUs
cpu_sysrt_info
real-time priority band
Real-Time Priority Band
real-time program
and frame scheduler
Frame Scheduler
terminology
Real-Time Programs
reenabling react
Reenabling REACT
REFCLK_FREQ
External Interrupt Output for the PCIE-RT Card
register access
Direct RTC Access
register format
PCIE-RT card
External Interrupt Output for the PCIE-RT Card
registration of callout
Callout Registration
repeat frame
Injecting a Repeat Frame
requirements
REACT Requirements
response time guarantee
Maximum Response Time Guarantee
restricting a CPU
Restricting a CPU from Scheduled Work and Isolating it from Scheduler Load Balancing
RHEL requirement
REACT Requirements
round-robin
Special Scheduling Disciplines
RPMs
REACT RPMs
RT_NO_WAIT
cpu_sysrt_add
cpu_sysrt_delete
RT_WAIT
cpu_sysrt_add
cpu_sysrt_delete
RTC
Real-Time Clocks
RTC access
Direct RTC Access
rtcpu
Frame Scheduler Basics
rtcpu devices
react
Command Overview
RTCPUS
cpu_sysrt_info
RTMEMS
cpu_sysrt_info
sched_setparam()
Real-Time Priority Band
sched_setscheduler()
Special Scheduling Disciplines
Real-Time Priority Band
scheduling
Scheduling Concepts
scheduling disciplines
Using the Scheduling Disciplines
scheduling disciplines
Special Scheduling Disciplines
select system call
Waiting for Interrupts
SGI Linux Trace
REACT
™
Features
REACT
™
Features
SGI UV 2000
Determining the Clock Source
sgi_rtc
Determining the Clock Source
sgi-extint-kmp-*
REACT RPMs
sgi-lttng-modules-kmp-default
Installing LTTng on SLES
SGI-REACT-ltt
Installing LTTng on SLES
SLES
Installing LTTng on SLES
sig_dequeue
Setting Frame Scheduler Signals
sig_overrun
Setting Frame Scheduler Signals
sig_underrun
Setting Frame Scheduler Signals
sig_unframesched
Setting Frame Scheduler Signals
signal
Using Signals Under the Frame Scheduler
signal handler
Master Controller Thread
Slave Controller Thread
SIGRTMIN
Setting Frame Scheduler Signals
SIGUSR1
Setting Frame Scheduler Signals
SIGUSR2
Setting Frame Scheduler Signals
simulator
Simulators and Stimulators
single frame scheduler start
Starting a Single Scheduler
slave controller thread
Slave Controller Thread
slave scheduler
Synchronized Scheduler Concepts
SLES requirement
REACT Requirements
socket programming
Socket Programming
soft real-time program
Real-Time Programs
software latency
Components of Interrupt Response Time
Software Latency
source attribute file
sysfs
Attribute Files
sourcelist attribute file
sysfs
Attribute Files
special scheduling disciplines
Special Scheduling Disciplines
stimulator
Simulators and Stimulators
strace
Real-Time Priority Band
Diagnostic Tools
swapping requirement
REACT Requirements
sync group
Synchronized Scheduler Concepts
synchronized TSC
Determining the Clock Source
synchronous I/O
Conventional Synchronous I/O
/sys/class/extint/extint#/
sysfs
Attribute Files
sysfs attribute files
sysfs
Attribute Files
system configuration generation
REACT System Configuration
system-call time base
Frame Scheduler Basics
thread
Controller Thread
thread control
Controlling Kernel and User Threads
thread programming model
Thread Programming Model
time base for frame scheduler
Selecting a Time Base
time base support
Frame Scheduler Basics
time estimation
Estimating Available Time
time slices
Scheduling Concepts
TIMER
External Interrupt Output for the PCIE-RT Card
Timer interrupt control REACT library routine
cpu_shield
timer interrupts
Interrupt Distribution Control
Timer Interrupts
timer_create()
Real-Time Clocks
TIMER_OVR
External Interrupt Output for the PCIE-RT Card
TIMER_PERIOD_COUNTER
External Interrupt Output for the PCIE-RT Card
TIMER_PERIOD_CTR
External Interrupt Output for the PCIE-RT Card
TIMER_PERIOD_CTR_NEXT
External Interrupt Output for the PCIE-RT Card
TIMER_PERIOD_NEXT
External Interrupt Output for the PCIE-RT Card
TIMER_WIDTH
External Interrupt Output for the PCIE-RT Card
TIMER_WIDTH_CTR
External Interrupt Output for the PCIE-RT Card
TIMER_WIDTH_CTR_NEXT
External Interrupt Output for the PCIE-RT Card
time-share applications
Special Scheduling Disciplines
time-stamp counter
Determining the Clock Source
toggle mode
PCIE-RT card
External Interrupt Output for the PCIE-RT Card
top
Diagnostic Tools
trace
REACT
™
Features
trace information
Getting Trace Information
transport delay
Simulators and Stimulators
troubleshooting
Troubleshooting
tsc
Determining the Clock Source
Determining the Clock Source
ULI
ULI Functional Overview
See
User-level interrupt (ULI)
ULI_block_intr
Common Arguments for Registration Functions
ULI_destroy
Common Arguments for Registration Functions
ULI_register_irq()
Common Arguments for Registration Functions
Registering a Per-IRQ Handler
ULI_sleep()
Common Arguments for Registration Functions
ULI_unblock_intr
Common Arguments for Registration Functions
ULI_wakeup()
Common Arguments for Registration Functions
underrun exception
Detecting Overrun and Underrun
underrun, in frame scheduler
Real-Time Discipline
unsupported hardware device capabilities
Making Use of Unsupported Hardware Device Capabilities
unsynchronized TSC
Determining the Clock Source
usecs (microseconds)
Maximum Response Time Guarantee
user access
Specifying Permissions
user capabilities
Specifying Permissions
user thread control
Controlling Kernel and User Threads
user thread dispatch
User Threads Dispatch
usercaps
cpu_sysrt_set_caps
USERCAPS_SET_EFFECTIVE
cpu_sysrt_set_allowed_caps
USERCAPS_SET_PERMITTED
cpu_sysrt_set_allowed_caps
user-level interrupt (ULI)
concurrency
Planning for Concurrency: Declaring Global Variables
functional overview
ULI Functional Overview
global variables
Planning for Concurrency: Declaring Global Variables
handler interaction
Interacting With the Handler
initializing
Steps in Setting Up ULI
interrupt handler registration
Registering the Interrupt Handler
multiple devices
Using Multiple Devices
mutual exclusion
Achieving Mutual Exclusion
per-IRQ handler
Registering a Per-IRQ Handler
program address space locking
Locking the Program Address Space
restrictions on handler
Restrictions on the ULI Handler
ULI_block_intr()
Achieving Mutual Exclusion
ULI_sleep ()
Interacting With the Handler
ULI_sleep () function
Using Multiple Devices
ULI_wakeup () function
Interacting With the Handler
user-level interrupts (ULI)
Sample User-Level Interrupt Programs
/usr/include/asm/param.h
Timer Interrupts
/usr/include/sn/timer.h
Direct RTC Access
/usr/include/sys/pthread.h
Frame Scheduler API
/usr/share/src/react/examples
Interrupt Information Templates
UV 100
Determining the Clock Source
Determining the Clock Source
Real-Time Clocks
Direct RTC Access
UV 1000
Real-Time Clocks
Direct RTC Access
UV 2000
Real-Time Clocks
Direct RTC Access
UV 300
Real-Time Clocks
UV 3000
Direct RTC Access
virtual memory locking
Virtual Memory Locking
virtual reality simulator
Virtual Reality Simulators
volatile keyword
Planning for Concurrency: Declaring Global Variables
Vsync time base
Frame Scheduler Basics
wave stimulator
Wave Tank Stimulator
write bitmask routine
cpu_sysrt_info