SGI Techpubs Library
Techpubs Library
Home/Search
Books by Product
What's New
Help


IRIX 6.5 Linux Hardware Freeware (IRIX) Windows
   
To further optimize your search, select from the following options:
 Search only in:
Search only titles    Show only 1 hit/book      Results/page:


IRIX 6.5  »  Books  »  Developer  »  
Topics in IRIX® Programming
(document number: 007-2478-010  /  published: 2004-04-21)   additional info | download

This manual discusses several topics of interest to programmers writing applications for the IRIX operating system on Silicon Graphics computers. These topics include memory management, interprocess communication, models of parallel computation, file and record locking, font access, and internationalization.

table of contents (expand all | collapse all)  |  list of figures  |  list of tables  |  list of examples  |  list of procedures  |  

   Front Matter
 - About This Manual
       What This Manual Contains
       What You Should Know Before Reading This Manual
     - Other Useful References
           Obtaining Manuals
       Conventions Used in This Manual
       Reader Comments
 - Part I. The Process Address Space
     - Chapter 1. Process Address Space
         - Defining the Address Space
               Address Space Boundaries
               Page Numbers and Offsets
               Address Definition
               Address Space Limits
               Delayed and Immediate Space Definition
               Page Validation
               Read-Only Pages
               Copy-on-Write Pages
           Interrogating the Memory System
         - Mapping Segments of Memory
             - Segment Mapping Function mmap()
                   Describing the Mapped Object
                   Describing the New Segment
             - Mapping a File for I/O
                   Mapped File Sizes
                   Apparent Process Size
                   Mapping Portions of a File
                   File Permissions
                   NFS Considerations
                   File Integrity
               Mapping a File for Shared Memory
               Mapping a Segment of Zeros
               Mapping Physical Memory
               Mapping Kernel Virtual Memory
               Mapping a VME Device
             - Choosing a Segment Address
                   Segments at Fixed Offsets
                   Segments at a Fixed Address
         - Locking and Unlocking Pages in Memory
             - Memory Locking Functions
                   Locking Program Text and Data
                   Locking Mapped Segments
                   Locking Mapped Files
               Unlocking Memory
         - Additional Memory Features
               Changing Memory Protection
               Synchronizing the Backing Store
               Releasing Unneeded Pages
         - Using Origin2000 Nonuniform Memory
             - About Origin Hardware
                   Basic Building Blocks
                   Uniform Addressing
             - Cache Coherency
                   Cache Coherency in CHALLENGE Systems
                   Cache Coherency in Origin Systems
             - About CC-NUMA Performance Issues
                   About Default Memory Location
                   About Large Memory Use
                   About Multithreaded Memory Use
             - Dealing With Cache Contention
                   Detecting Cache Contention
                   Correcting Cache Contention Problems
             - Getting Optimum Memory Placement
                   Detecting Memory Placement Problems
                   Programming Desired Memory Placement
                   Using Compiler Directives for Memory Placement
                   Taking Advantage of First-Touch Allocation
                   Using Round-Robin Allocation
                   Using Dynamic Page Migration
                   Using Explicit Memory Placement
 - Part II. Interprocess Communication
     - Chapter 2. Interprocess Communication
           Types of Interprocess Communication Available
         - Using POSIX IPC
               POSIX IPC Name Space
           Using IRIX IPC
         - Using System V IPC
             - SVR4 IPC Name Space
                   Configuring the IPC Name Space
                   Listing and Removing Persistent Objects
                   Access Permissions
                   Choosing and Communicating Key Values
                   Using ID Numbers
                   Private Key Values
           Using 4.2 BSD IPC
     - Chapter 3. Sharing Memory Between Processes
         - Overview of Memory Sharing
               Shared Memory Based on mmap()
               Sharing Memory Between 32-Bit and 64-Bit Processes
         - POSIX Shared Memory Operations
             - Creating a Shared Object
                   Shared Object Pathname
                   Shared Object Open Flags
                   Shared Object Access Mode
                   Using the Shared Object File Descriptor
               Using a Shared Object
               Example Program
         - IRIX Shared Memory Arenas
               Overview of Shared Arenas
               Initializing Arena Attributes
               Creating an Arena
             - Joining an Arena
                   Restricting Access to an Arena
                   Arena Access From Processes in a Share Group
               Allocating in an Arena
               Exchanging the First Datum
         - System V Shared Memory Functions
             - Creating or Finding a Shared Memory Segment
                   Attaching a Shared Segment
             - Managing a Shared Segment
                   Information About Shared Memory
             - Shared Memory Examples
                   Example of Creating a Shared Segment
                   Example of Attaching a Shared Segment
     - Chapter 4. Mutual Exclusion
         - Overview of Mutual Exclusion
               Test-and-Set Instructions
               Locks
               Semaphores
               Condition Variables
               Barriers
         - POSIX Facilities for Mutual Exclusion
               Managing Unnamed Semaphores
             - Managing Named Semaphores
                   Creating a Named Semaphore
                   Closing and Removing a Named Semaphore
               Using Semaphores
               Using Mutexes and Condition Variables
         - IRIX Facilities for Mutual Exclusion
             - Using IRIX Semaphores
                   Creating Normal Semaphores
                   Creating Polled Semaphores
                   Operating on Semaphores
             - Using Locks
                   Creating and Managing Locks
                   Claiming and Releasing Locks
               Using Barriers
             - Using Test-and-Set Functions
                   Using Test-and-Set
                   Using Compare-and-Swap
                   Using Compiler Intrinsics for Test-and-Set
               Creating or Finding a Semaphore Set
               Managing Semaphore Sets
               Using Semaphore Sets
             - Example Programs
                   Example Uses of semget()
                   Example Uses of semctl() for Management
                   Example Uses of semctl() for Query
                   Example Uses of semop()
                   Using the Examples
     - Chapter 5. Signalling Events
         - Signals
               Signal Numbers
               Signal Implementations
             - Signal Blocking and Signal Masks
                   Multiple Signals
             - Signal Handling Policies
                   Default Handling
                   Ignoring Signals
                   Catching Signals
                   Synchronous Signal Handling
               Signal Latency
               Signals Under X-Windows
             - POSIX Signal Facility
                   Signal Masking
                   Using Synchronous Handling
                   Using Asynchronous Handling
               System V Signal Facility
               BSD Signal Facility
         - Timer Facilities
               Timed Pauses and Schedule Cession
               Time Data Structures
               Time Signal Latency
               How Timers Are Managed
             - POSIX Timers
                   Getting Program Execution Time
                   Creating Timestamps
                   Using Interval Timers
               BSD Timers
               Hardware Cycle Counter
     - Chapter 6. Message Queues
         - Overview of Message Queues
               Implementation Differences
               Uses of Message Queues
         - POSIX Message Queues
             - Managing Message Queues
                   Creating a Message Queue
                   Opening an Existing Queue
                   Specifying Blocking or Nonblocking Access
             - Using Message Queues
                   Sending a Message
                   Receiving a Message
                   Using Asynchronous Notification
             - Example Programs
                   Example of mq_getattr()
                   Example of mq_open()
                   Example of mq_send()
                   Example of mq_receive()
         - System V Message Queues
             - Managing SVR4 Message Queues
                   Creating a Message Queue
                   Accessing an Existing Queue
                   Modifying a Message Queue
                   Removing a Message Queue
             - Using SVR4 Message Queues
                   Sending a Message
                   Receiving a Message
             - Example Programs
                   Example of msgget
                   Example of msgctl
                   Example of msgsnd
                   Example of msgrcv
 - Part III. Advanced File Control
     - Chapter 7. File and Record Locking
         - Overview of File and Record Locking
             - Terminology
                   Record
                   Read (Shared) Lock
                   Write (Exclusive) Lock
                   Advisory Locking
                   Mandatory Locking
                   Lock Promotion and Demotion
           Controlling File Access With File Permissions
         - Using Record Locking
               Opening a File for Record Locking
             - Setting a File Lock
                   Whole-File Lock With fcntl()
                   Whole-File Lock With lockf()
                   Whole-File Lock With flock()
               Setting and Removing Record Locks
               Getting Lock Information
               Deadlock Handling
           Enforcing Mandatory Locking
         - Record Locking Across Multiple Systems
               NFS File Locking
               Configuring NFS Locking
               Performance Impact
     - Chapter 8. Using Asynchronous I/O
         - About Synchronous and Asynchronous I/O
               About Synchronous Input
               About Synchronous Output
             - About Asynchronous I/O
                   Asynchronous I/O Functions
                   Asynchronous I/O Control Block
             - Initializing Asynchronous I/O
                   Implicit Initialization
                   Initializing with aio_sgi_init()
                   When to Initialize
             - Scheduling Asynchronous I/O
                   Assuring Data Integrity
             - Checking the Progress of Asynchronous Requests
                   Polling for Status
                   Checking for Completion
                   Establishing a Completion Signal
                   Establishing a Callback Function
                   Holding Callbacks Temporarily
               Multiple Operations to One File
           Asynchronous I/O Example
     - Chapter 9. High-Performance File I/O
         - Using Synchronous Output
               About Buffered Output
               Requesting Synchronous Output
         - Using Direct I/O
               Direct I/O Example
           Using a Delayed System Buffer Flush
         - Using Guaranteed-Rate I/O
             - About Guaranteed-Rate I/O
                   About Types of Guarantees
                   About Device Configuration
               Creating a Real-time File
               Requesting a Guarantee
               Releasing a Guarantee
 - Part IV. Models of Parallel Computation
     - Chapter 10. Models of Parallel Computation
         - Parallel Hardware Models
               Parallel Programs on Uniprocessors
             - Types of Memory Systems
                   Single Memory Systems
                   Multiple Memory Systems
                   Hierarchic, Nonuniform Memory Systems
         - Parallel Execution Models
               Process-Level Parallelism
               Thread-Level Parallelism
               Statement-Level Parallelism
             - Message-Passing Models
                   Shared Memory (SHMEM) Model
                   Message-Passing Interface (MPI) Model
                   Parallel Virtual Machine (PVM) Model
     - Chapter 11. Statement-Level Parallelism
         - Products for Statement-Level Parallelism
               Silicon Graphics Support
               Products from Other Vendors
           Creating Parallel Programs
         - Managing Statement-Parallel Execution
               Controlling the Degree of Parallelism
               Choosing the Loop Schedule Type
               Distributing Data
     - Chapter 12. Process-Level Parallelism
         - Using Multiple Processes
             - Process Creation and Share Groups
                   Process Creation
                   Process Management
                   Process “Reaping”
             - Process Scheduling
                   Controlling Scheduling With IRIX and BSD-Compatible Facilities
                   Controlling Scheduling With POSIX Functions
               Self-Dispatching Processes
           Parallelism in Real-Time Applications
     - Chapter 13. Thread-Level Parallelism
           Overview of POSIX Threads
         - Compiling and Debugging a Pthread Application
               Compiling Pthread Source
               Debugging Pthread Programs
         - Creating Pthreads
               Initial Detach State
               Initial Scheduling Scope, Priority, and Policy
               Thread Stack Allocation
         - Executing and Terminating Pthreads
               Getting the Thread ID
               Initializing Static Data
               Setting Event Handlers
               Terminating a Thread
               Joining and Detaching
           Using Thread-Unique Data
         - Pthreads and Signals
               Setting Signal Masks
               Setting Signal Actions
               Receiving Signals Synchronously
         - Scheduling Pthreads
               Contention Scope
               Scheduling Policy
               Scheduling Priority
         - Synchronizing Pthreads
             - Mutexes
                   Preparing Mutex Objects
                   Using Mutexes
             - Condition Variables
                   Preparing Condition Variables
                   Using Condition Variables
             - Read-Write Locks
                   Preparing Read-Write Locks
                   Using Read-Write Locks
     - Chapter 14. Message-Passing Parallelism
           Choosing a Message-Passing Model
         - Choosing Between MPI and PVM
               Differences Between PVM and MPI
 - Part V. Working With Fonts
     - Chapter 15. Working With Fonts
         - Font Basics
             - Terminology
                   Typography
                   Character
                   Font
                   Font Family, or Typeface
               How Resolution Affects Font Size
               Font Names
               Writing Programs That Need to Use Fonts
         - Using Fonts With the X Window System
             - Listing and Viewing Fonts
                   Getting a List of Font Names and Font Aliases
                   Viewing Fonts
               Getting the Current X Font Path
               Changing the X Font Path
         - Installing and Adding Font and Font Metric Files
             - Locations of Font and Font Metric Files
                   Conventions for Bitmap Font Filenames
                   Creating Font Aliases
             - Adding Font and Font Metric Files
                   Adding a Bitmap Font
                   Adding an Outline Font
                   Adding a Font Metric File
           Downloading a Type 1 Font to a PostScript Printer
 - Part VI. Internationalizing Your Application
     - Chapter 16. Internationalizing Your Application
         - Overview of Internationalization
             - Some Definitions of Internationalization
                   Locale
                   Internationalization (i18n)
                   Localization (l10n)
                   Nationalized Software
                   Multilingual Software
               Areas of Concern in Internationalizing Software
               Standards
               Internationalizing Your Application: The Basic Steps
               Additional Reading on Internationalization
         - Using Locales
             - Setting the Current Locale
                   Using Locale Categories
                   Setting the Locale
                   Empty String
                   Nonempty Strings in Calls to setlocale()
                   Location of Locale-Specific Data
                   Locale Naming Conventions
             - Limitations of the Locale System
                   Multilingual Support
                   Misuse of Locales
                   No Filesystem Information for Encoding Types
         - Character Sets, Codesets, and Encodings
               Eight-Bit Cleanliness
               Character Representation
             - Multibyte Characters
                   Use of Multibyte Strings
                   Handling Multibyte Characters
                   Conversion to Constant-Size Characters
                   Finding the Number of Bytes in a Character
                   How Many Bytes in an MB String?
                   How Many Characters in an MB String?
             - Wide Characters
                   Uses for wchar Strings
                   Support Routines for Wide Characters
                   Conversion to MB Characters
               Reading Input Data
         - Cultural Items
               Collating Strings
             - Specifying Numbers and Money
                   Using printf()
                   Using localeconv()
                   Using strfmon()
               Formatting Dates and Times
               Character Classification and ctype
               Regular Expressions
         - Locale-Specific Behavior
             - Overview of Locale-Specific Behavior
                   Local Customs
                   Regular Expressions
                   ANSI X3.159-198X Standard for C
             - Native Language Support and the NLS Database
                   Configuration Data
                   Collating Sequence Tables
                   Character Classification Tables
                   Shift Tables
                   Language Information
             - Using Regular Expressions
                   Internationalized Regular Expressions
               Cultural Data
             - NLS Interfaces
                   NLS Utilities
                   NLS Library Functions
               XSI Curses Interface
         - Strings and Message Catalogs
             - XPG/4 Message Catalogs
                   Opening and Closing XPG/4 Catalogs
                   Using an XPG/4 Catalog
                   XPG/4 Catalog Location
                   Creating XPG/4 Message Catalogs
                   Compiling XPG/4 Message Catalogs
             - SVR4 MNLS Message Catalogs
                   Putting MNLS Strings Into a Catalog
                   Using MNLS in Shell Scripts
                   Specifying MNLS Catalogs
                   Getting Strings From MNLS Message Catalogs
                   Using pfmt()
                   Labels, Severity, and Flags
                   Format Strings for pfmt()
                   Using fmtmsg()
                   Internationalizing File Typing Rule Strings With MNLS
               Variably Ordered Referencing of printf() Arguments
         - Internationalization Support in X11R6
             - Limitations of X11R6 in Supporting Internationalization
                   Vertical Text
                   Character Sets
                   Xlib Interface Change
               Resource Names
             - Getting X Internationalization Started
                   Initialization for Toolkit Programming
                   Initialization for Xlib Programming
             - Fontsets
                   Example: EUC in Japanese
                   Specifying a Fontset
                   Creating a Fontset
                   Using a Fontset
               Text Rendering Routines
               New Text Extents Functions
           Internationalization Support in Motif
         - Translating User Input
             - About User Input and Input Methods
                   Reuse Sample Code
                   GL Input
             - About X Keyboard Support
                   Keys, Keycodes, and Keysyms
                   Composed Characters
                   Supported Keyboards
             - Input Methods (IMs)
                   Opening an Input Method
             - IM Styles
                   Root Window
                   Off-the-Spot
                   Over-the-Spot
                   On-the-Spot
                   Setting IM Styles
                   Using Styles
             - Input Contexts (ICs)
                   Find an IM Style
                   IC Values
                   Pre-Edit and Status Attributes
                   Creating an Input Context
                   Using the IC
             - Events Under IM Control
                   Using XFilterEvent()
                   Using XLookupString(), XwcLookupString(), and XmbLookupString()
         - GUI Concerns
               X Resources for Strings
             - Layout
                   Dynamic Layout
                   Constant Layout
                   Localized Layout
                   IRIS IM Localization With editres
               Icons
         + Popular Encodings
   Appendix A. ISO 3166 Country Names and Abbreviations
   Index


home/search | what's new | help