EXECUTIVE SUMMARY
IRIX 6.1 is a 64-bit upwardly compatible revision of IRIX 6.0.1. This operating system supports high-performance computing environments with a new file system, a higher-performance 32-bit compilation kit, and new networking and system administration features initially released in IRIX 5.3.IRIX 6.1 is supported on Silicon Graphics® POWER CHALLENGE(TM), POWER Onyx(TM), and POWER Indigo2(TM) platforms. A subsequent operating system release will support all currently shipping Silicon Graphics systems.
For the first time, IRIX 6.1 bundles XFS(TM), the new, state-of-the-art filesystem for Silicon Graphics systems. XFS was an unbundled option on IRIX 6.0.1 and IRIX 5.3. In addition, 32- and 64-bit software compiled on R4x00 or R8000 processors using IRIX 5 or later will generally just run on R8000 systems with IRIX 6.1. 32-bit binaries built under 5.x will run even faster on R8000-based systems if they are recompiled on IRIX 6.1 using the new N32 software developers kit. Other vendors force developers to port to 64-bits to run on a new architecture. Silicon Graphics developed R8000 and IRIX 6.1 in a way that preserves 32-bit compatibility and now encourages a simple recompilation to take full advantage of R8000 performance, while preserving 32-bit addressing.
IRIX 6.1 enables many new networking and system administration
features including:
- 64-bit NFSv3 for faster data transfers and distributed 64-bit addressing
- Parallel TCP/IPx for higher parallel networking throughput
- IRIXpro(TM) for professional system administrators
- Performance CoPilot(TM) for professional network administrators
INTRODUCTION
This paper provides a technical outline of the features available in the IRIX 6.1 operating system, including key information about the R8000 processor, the IRIX 6 Development Option (IDO), changes made to support 64-bits, the advantages of fully migrating applications to a 64-bit operating system and architecture, and compatibility with earlier versions of IRIX. In the process, the paper summarizes the key features and functionality of IRIX 6.1.
The R8000 Processor
The R8000 microprocessor chip set is the first 64-bit superscalar
implementation
of the MIPS® 4 Instruction Set Architecture, which is a backward-compatible
superset of the MIPS 3 architecture. The superscalar implementation of
R8000 achieves extremely affordable supercomputing performance. The R8000
chip
set combines a large, fast-access, high-throughput cache subsystem with
high- performance floating-point capabilities. Its cache and memory
bandwidths satisfy applications with large working sets of data. R8000 is
able to sustain high levels of performance once only possible on much
larger and more expensive vector supercomputer systems.
| Advanced MIPS Instruction Sets | ||
| MIPS 1 | R3000® | MIPS 1 Instrucion Set |
| MIPS 2 | R4000® | MIPS 1 Instruction Set Plus Ide1/sde1, single instruction to load/store double percision Branch likely |
| MIPS 3 | R4400(TM) | MIPS 2 Instruction Set Plus 64-bit integer operations 32 double precision floating-point registers |
| MIPS 4 | R8000 | MIPS 3 Instruction Set Plus MADD (Multiply and Add-Double) Indexed floating-point load/store Conditional move More condition code registers |
The R8000 chip set includes:
- Four-way superscalar architecture, capable of executing six operations per clock cycle
- True 64-bit integer and floating-point operations, registers, and virtual addressing
- Fused multiply-add (MADD) instruction
- Full upward-compatibility with earlier 32-bit and 64-bit MIPS microprocessors
- Very high performance, particularly on floating-point operations
- 64-bit virtual address space (2^40 bits or 1 TB)
- Large physical memory (currently 16 GB)
- Large file size (1 TB at first release, future releases support 9 million TB or the system drive limits)
- Large file system size (1 TB at first release, future releases support 18 million TB or the system drive limits)
- Millions of files per directory
The IRIX 6.0 Development Option (IDO) includes MIPSpro(TM) compiler technology to generate MIPS 3 or MIPS 4 64-bit code. The development environment integrates the well-known Silicon Graphics 32-bit compilers with advanced MIPSpro compiler technology to provide MIPS 3 and MIPS 4 64-bit compilation. Include structures have been modified to provide the correct 32- or 64-bit sizes, and a hierarchy of libraries has been included to support both 32-bit and 64-bit development. This structure is described later in this paper.
Extensions include the definition of a new Extended Linking Format (ELF) object module format for 64-bit programs, ELF-64, which is supported in all the tools which work with object modules. ELF-64 is a 64-bit version of the ELF format used in IRIX 5.x and other System V Release 4 systems. The Dynamic Shared Object (DSO) architecture was also extended to support 64-bit addressing. DSO technology is used to provide upward compatibility between IRIX 5 and IRIX 6, and by dynamically binding applications to shared libraries at execution time enables a single "shrink-wrapped" version that can operate without change on a wide variety of MIPS hardware platforms.
IRIX 6.1 includes the latest releases of the X11 Window System(TM) and IRIX IM, the Silicon Graphics enhanced version of OSF/Motif(TM) Release 1.2.4. Libraries for both have been changed to support 64-bit addressing. The X server is X11R5 to provide behavior compatible with 32-bit X11R5 executables without recompilation. OpenGL® is fully supported for 32-bit and 64-bit development.
64-Bit Type Changes-The LP64* Model
64-bits wide implies that pointers are 64-bit so that the virtual address
space of a process can (potentially) be 2^64 instead of 2^32 bits. To
eliminate ambiguity where other data types are 64 bits, Table 2 summarizes
the 64-bit environment versus the 32-bit IRIX and
Intel(TM) x86 environments.
| C Data Type Models | ||||
|---|---|---|---|---|
| C Data Type | Current IRIX 32-bit | IRIX 6 LP64 | Intel x86 | |
| char | 8 | 8 | 8 | |
| short | 16 | 16 | 16 | |
| int | 32 | 32 | 16 | |
| long int | 32 | 64 | 32 | |
| long long int | 64 | 64 | N/A | |
| pointer | 32 | 64 | 16/32 | |
| float | 32 | 32 | 32 | |
| double | 64 | 64 | N/A | |
| long double* | 64 | 128 | N/A | |
With the C compiler, the code generated using the -64 and either mips3 or -mips4 flags for long/void or longlong now uses the processor's 64-bit integer instructions. The Fortran compiler has no data size changes, as its types have specific sizes, but -64 and mips3/mips4 flags also generate 64-bit integer instructions and 64-bit addresses. 32-bit applications will contain different size structures than 64-bit code, handled by the kernel which converts all system calls from 32-bit binary to 64-bit kernel format. Languages supported in IRIX 6.1 include 64-bit Assembler, C, C++, and Fortran 77. The Developer Magic(TM) environment provides a suite of tools including a debugger and profiler that support 64-bit applications.
Procedure Calling Convention
-
The MIPSpro compilers include other efficiencies in emitted code which may
benefit 64-bit applications. These are:
- 8 integer argument registers
- 32 floating-point registers
- Global pointer (gp) is saved by the callee
- Small structures are passed in registers
- Floating-point arguments are passed more efficiently
64-Bit Fortran Library Support
-
64-bit Fortran libraries include:
- Basic Linear Algebra Subprograms (BLAS)
- LAPACK, LINPACK, EISPACK
- Signal Processing routines for Fast Fourier Transforms and Convolutions
- SCIPORT (Portable Version of Cray Research SCILIB)
- SLATECT Mathematical Subprogram Library
64-bit versions of X11R6 and IRIX IM libraries are available for graphics developers, with modifications to imake config files, xmkmf, and the uil user interface language compiler. Since the 64-bit version of libXm implements standard Motif(TM) styles without Silicon Graphics extensions, users may notice slight visual differences between 32- and 64-bit Motif applications.
64-Bit OpenGL
OpenGL is a graphics software library that allows programmers to produce
high-quality color images of 3D objects. The OpenGL standard is governed by
the Architecture Review Board, an industry consortium which insures
multiplatform compatibility with applications based on OpenGL. IRIX 6.1
includes a 64-bit version of OpenGL, including files and libraries to
facilitate the development
of 64-bit OpenGL applications. The 32-bit version of the IRIS GL(TM) and
OpenGL libraries are supplied so that customers can execute their 32-bit
applications.
As IRIS GL is superceded by OpenGL, a 64-bit version of IRIS GL is not
supplied. Software with GL for 64 bits will require a port to OpenGL, using
the toogl translation tool and the OpenGL Porting Guide.
INCLUDE FILES AND LIBRARY DIRECTORY STRUCTURES
Since both 32- and 64-bit environments are supported under IRIX 6.1,
multiple sets of libraries reside in different directories. 64-bitcompilatio
ns, targeted at the R8000 and MIPS 4 ISA, are the default. The library path
must be changed for other targets.
Each header file under /usr/include will support both 32-bit and 64-bit compilation. The following directory structure is used for IRIX 6.1 libraries:
| Directory Structures used in IRIX 6.1 | |
|---|---|
| Directories | Contents |
| /usr/lib/*.so | IRIX 5.2 DSOs |
| /usr/lib/*.a | IRIX 5.2 static libraries |
| /usr/lib/nonshared/*.a | IRIX 5.2 non-shared libraries |
| /usr/lib/mips2/*.so | IRIX 5.2 MIPS DSOs |
| /usr/lib/mips2/*.a | IRIX 5.2 MIPS2 static libraries |
| /usr/lib/mips2/nonshared/*.a | IRIX 5.2 MIPS 2 non-shared libraries |
| /usr/lib64 | 64-bit libraries and tools |
| /usr/lib64/*.so | 64-bit DSOs (symbolic link) |
| /usr/lib64/*.a | 64-bit static libraries (symbolic link) |
| /usr/lib64/mips3/*.so | 64-bit MIPS 3 DSOs |
| /usr/lib64/mips3/*.a | 64-bit MIPS 3 static libraries |
| /usr/lib64/mips4/*.so | 64-bit MIPS 4 DSOs |
| /usr/lib64/mips4/*.a | 64-bit MIPS 4 static libraries |
| /usr/lib64/nonshared | 64-bit non-shared libraries |
| /usr/lib64/mips3/nonshared/*.a | 64-bit non-shared MIPS 3 static libraries |
| /usr/lib64/mips4/nonshared/*.a | 64-bit non-shared MIPS 4 static libraries |
| /usr/lib64/cmplrs/* | 64-bit compiler tools |
| IRIX 6.1 System Structures extended to support 64-bits. | |||
|---|---|---|---|
| < direct.h> | < fcntl.h> | < ftw.h> | < grp/h> |
| < locale.h> | < math.h> | < netconfig.h> | < netdir.h> |
| < nl_types.h> | < poll.h> | < pwd.h> | < rpc.h> |
| < search.h> | < setjmp.h> | < sygaction.h> | < signal.h> |
| < stddef.h> | < stdio.h> | < stdib.h> | < stropts.h> |
| < sys/ipc.h> | < sys/msg.h> | < sys/procset.h> | < sys/resource.h> |
| < sys/sem.h> | < sys/shm.h> | < sys/siginfo.h> | < sys/stat.h> |
| < sys/statvfs.h> | < sys/time.h> | < sys/times.h> | < sys/tiuser.h> |
| < termios.h> | < ucontext.h> | ||
ADVANTAGES OF CONVERTING TO 64-BIT ADDRESSING
Note again that porting to 64-bit addressing and datatypes is not required.
IRIX 6.1 supports 32-bit applications from IRIX 5.x. 32-bit applications
recompiled with N32 will gain the full performance of R8000. Applications
should be converted only if they would benefit from 64-bit features. These
features include:
- 64-bit logical/arithmetic operations
- 64-bit virtual addressing
- File size greater than 2 gigabytes
The IRIX 6.1 development environment contains compiler features and library routines which support migration from 64-bit Cray(TM), Convex, and DEC environments.
64-BIT PROGRAMMING CONSIDERATIONS
When porting from 32- to 64-bit addressing a C or Fortran application from
32 to 64 bits, focus on datatype sizes, pointer arithmetic, and operations
which make implicit or explicit assumptions about data structures or byte
alignments. Fortran ports are generally easier due to strong data typing
and less frequent address passing. Some bad practices cannot be found
easily by automated tools: Developer Magic ProDev(TM) can help but cannot
substitute for human intervention and insight.
N32 SOFTWARE DEVELOPERS KIT
Nearly all 32-bit binaries built on IRIX 5 run on IRIX 6.1, although on
occasion
an application needs to be recompiled, or even recoded. Though 32-bit
binaries will run on a system based on R8000, they will not take full
advantage of the performance features of the R8000 processor or the MIPS 4
ISA.
64-bit support requires a compilation system that produces 64-bit executables using 64-bit addressing, as well as 64-bit hardware and a 64-bit operating system environment. Version 6.1 of the Silicon Graphics compiler supports MIPS 4 64-bit compilation. Header files, libraries, the Dynamic Shared Objects architecture, X11, IRIX IM, and OpenGL have also modified to support 64-bits. Many Independent Software Vendors (ISVs) have ported already; large address spaces are attractive for computer-aided engineering (CAE), while very large files are important in geophysics. As noted above, the 64-bit environment brings other advantages: 64-bit logical operations double the speed of some inner loops, and 128-bit (quad) precision is valued by other users.
As discussed, a 32-to-64-bit port is not necessarily simple, requiring constant attention to datatype sizes and pointer arithmetic, and awareness of new compiler options and the location of appropriate header files and libraries. Some applications may need to be restructured or partially rewritten. As a result, many developers have not yet ported to the new 64-bit ABI.
The N32 Software Developers Kit allows existing 32-bit binaries to take advantage of the performance features of the R8000 chip set and MIPS 4 ISA. Developers who simply recompile with the 6.1 compilers on IRIX 6.1 with the -n32 -mips4 flags set will generate binaries that use all 32 floating-point registers, 8 argument registers, and the MADD instruction of the R8000/MIPS 4 ISA. With N32, fundamental data types do not change: All addressing is 32-bit. When N32 is available on R4x00 platforms later in 1995, one set of binaries can be targeted to run on all currently-shipping Silicon Graphics systems.
64-BIT IRIX 6.1 FEATURES
Large Processes
A 64-bit user process can grow to a virtual address space of 2^40 bytes (1
Terabyte), provided the system has sufficient memory and swap space. In
contrast, 32-bit systems are limited to 2-gigabyte processes - larger tasks
must be awkwardly segmented and overlaid to run in this address space.
32-bit virtual address space limitations are a primary driver for migration
to 64 bits.
Large Physical Memory
With IRIX 6.1 physical memory can be up to 16 gigabytes (the current
POWER CHALLENGE system limit). Having more memory than the 2
gigabytes maximum possible on a 32-bit system permits more or larger
tasks to be run simultaneously in multitasking environments.
New Advanced 64-Bit Filesystem
64-bit addressing allows the use of individual files and filesystems larger
than
2 gigabytes. Designed from the ground up, XFS is an advanced 64-bit
journalled filesystem with integrated volume management and guaranteed rate
I/O. XFS today supports files as large as 1 terabyte, and sparse files as
large as 9 million terabytes (2^63-1). Filesystems can also grow to 1
terabyte, and directories have successfully held 67 million files in
internal testing.
XFS uses database journalling technology to provide very fast recovery. No filesystem checking utility is needed-the system quickly references a small log of recently updated filesystem transactions after a system crash. Similarly, the traditional UNIX® filesystem checking utility does not scale as CPUs and disk are added; a logging filesystem, by contrast, does scale as disk and CPUs are added. The XFS volume manager xlv is a superset of the lv volume manager and supports striping, concatenation, and (optionally) disk mirroring. The system administrator can make on-line dynamic changes to volumes, including extending the size of a mounted filesystem. The XFS filesystem allows creation of filesystems with block sizes ranging from 512 bytes to 1 gigabyte. Filesystem extents, which provide contiguous data within a file, are configurable at file creation time and are multiples of the filesystem block size. The contiguous data control feature of XFS increases I/O performance because there is no delay due to disk seeks or rotational latency in accessing data stored randomly on disk. XFS supports guaranteed rate I/O, making it the only filesystem available that allows applications to reserve specific bandwidth to or from the filesystem.
Enhanced Distributed Filesystems
Distributed filesystems simplify the way data is accessed by making remote
files appear local. NFS, with an installed base of more than 3 million
seats, is the de facto UNIX standard for distributed filesystems.
Until recently, virtually all NFS implementations used the NFS Version 2 protocol (NFSv2). NFSv2 was not designed with today's high-performance networks or large file sizes in mind. NFSv2 limits the amount of data that can be transferred from one system to another in a single transaction to 8 KB, which in turn limits performance. Still, in 1994, Silicon Graphics was able to benchmark a 12-CPU CHALLENGE® XL on 4 FDDI rings at 7023 SPECsfs operations/second, 60 percent better than the next closest competitive system benchmarked, and still the outright SPECsfs leader today.
Silicon Graphics implemented NFS Version 3 (NFSv3) for the first time in IRIX 5.3. NFSv3 encourages use of larger block sizes, to produce better data transfer rates over high-speed networks. The Version 3 protocol also allows 64-bit file addressing, which makes it possible to use NFS to transfer files larger than 2 gigabytes over the network for the first time. Since V2 compatibility is preserved in ONC+ (in a more efficient implementation) customers get the best of both worlds: the performance of NFSv3 with the backward-compatibility of NFSv2. IRIX 6.1 implements NFSv3 and enhanced NFSv2 for the first time on a 6.x base.
Note: The Caching File System (CFS) is also a part of the ONC+ specification. IRIX 6.1 servers can export files to clients using CFS. IRIX 6.1 systems cannot cache files as clients using CFS. Similarly, NIS+ is part of ONC+. Based on the experience of Silicon Graphics and its customers' input, the company maintains that NIS+ is still immature. Therefore the company has not yet implemented NIS+ for shipment to customers.
Mature Multiprocessor Support for the R8000 Processor
IRIX 6.1 supports up to 18 R8000 processors per POWER CHALLENGE or
POWER Onyx system, providing unparalleled computing performance on
compute-intensive programs. Silicon Graphics pioneered multiprocessor RISC
systems running UNIX. MP versions of IRIX have been available since 1988,
hence IRIX 6.1 MP support is based on significantly more mature technology
than other technical RISC system vendors. The features of Silicon Graphics
multiprocessors allow demonstrable parallel speedups on many technical
applications, differentiating IRIX from other SMP UNIX offerings that have
focused on throughput in commercial workloads.
IRIX employs sophisticated synchronization techniques that allow multiple CPUs to execute in the kernel simultaneously, resulting in a multithreaded kernel. Within the IRIX kernel are more than 4,000 distinct MP-safe entry points. This allows very fine-grained locking; access to an individual data structure is synchronized rather than access to an entire subsystem-reducing the likelihood that Processor B must wait for Processor A to release a locked resource. As a result, IRIX offers exceptional scalablity and performance as processors are added.
IRIX 6x. Kernel Architecture
Memory Management
The IRIX virtual memory subsystem is essentially a "from-the-bottom-up"
design to support SVR4 virtual memory functionality, including mmap,
mprotect, and SVR4 Extended Linking Format (ELF) executables. The region
structure is SVR3 in nature, but has been heavily modified to gain MP
efficiencies related to cache flushing and TLB management. Virtual memory
is paged in a classic demand-paged model.
It is possible to add and subtract swap partitions on a running system. One can also swap to NFS partitions, to mirrored partitions, and to regular files. Another feature is that one can overcommit swap allocation, although this practice is not recommended and requires good knowledge of the application's working set.
Many tunable variables that affect memory management policies and performance are documented in the systune man page.
Process Management (Scheduling)
An IRIX process represents a thread of execution. The virtual address space
of a process, the contents of its user structure and proc table entry, and
the values contained in machine registers when the process is running
constitute the context of the process.
To support multiple processes, IRIX implements a process-scheduling algorithm that assures a fairly equitable division of processor time among all processes. This algorithm is non-preemptive, that is, the running process cannot be preempted by another process (but can be preempted by the kernel).
The running process can yield to another process "voluntarily," by making a system call (such as an I/O request) that causes it to sleep, in which case another process is selected to run. The running process can also be preempted by the kernel to handle an exception, in which case the process is rescheduled to resume immediately after the exception handler is finished.
The kernel also enforces limits on the amount of time a process can monopolize the processor (time slicing).
While the process management model discussed represents an apparently equitable resource sharing model, the effect of scheduling processes in a simplistic model does not maximize the computing capacity of a multiprocessor system. Inefficiencies can increase with the number of processors, and how these inefficiences are handled is central to the issue of how well a multiprocessor system scales in performance when additional processors are added.
POWER CHALLENGEarray(TM) System Support
IRIX 6.1 includes features to support future unbundled array functionality,
including the soon-to-be released Fair Share Scheduler (TM)
(based on SHARE II(TM)) and kernel level
check-point/restart (based on Hibernator II(TM)). Some functions that enhance
both arrays and all sizes of supercomputers, such as extended accounting,
are fully accessible today.
IRIX accounting has traditionally been process-oriented. This process orientation is tested on POWER CHALLENGE supercomputers when users need to bill time for compute resources to multiple projects or sum up resources used across the modes of POWER CHALLENGEarray. IRIX Extended Accounting adds up two features: projects and array sessions. Projects allows users to bill multiple projects separately. (Array sessions) group processes together across machines under a single identifier for unified accounting, job control, and more.
When inefficiences emerge in a particular combination of application and
environment, sophisticated scheduling options are available (in contrast to
other SMP UNIX offerings) including:
- Deadline Scheduling-
The system administrator can specify that a particular process will receive a specified proportion of CPU time in any recurring period, for example, 10,000 nanoseconds of CPU time for every 200,000 nanoseconds of elapsed time. The primary beneficiaries are applications such as video, which require regular output, or real-time data acquisition, which requires steady sampling from an external source. The process can block waiting for its time allocation or yield the processor if the required work is completed before its allocation has been used. This implemen- tation is more efficient and easier to use than timers and signals. - Processor Cache Affinity-
The scheduler can be instructed to consider the likelihood that a process to be scheduled may still have context in cache on a particular processor. This strategy improves performance by avoiding the penalty of reloading the cache. - Gang Scheduling-
The user can schedule related processes or threads to run as a group. Threads that communicate with each other using locks or semaphores will be assured of running in parallel, avoiding extra waiting and the associated performance penalty. - Processor Sets-
The administrator can reserve a set of processors to run specific tasks, parti- tioning multiple CPUs into groups on the same system. This enables enforcement of decisions about which applications may be run on a particular set, and can provide assurance to users that the optimal number of processors they need for a parallel task will be available when needed.
Synchronization Primitives
Silicon Graphics process synchronization primitives-spin locks, barriers,
and semaphores-are allocated from a shared memory "arena." These are
memory-mapped between processes and can permit pointers to be shared.
Synchronization primitives are implemented with the MIPS instructions
themselves, allowing for much faster synchronization than in traditional
System V mechanisms. Recent versions of IRIX have added new synchronization
primitives: test_and_set(3p), and test_and_add(3p).
Lightweight Processes
sproc is an interface that permits users to create lightweight processes
that share the virtual address space (and potentially other attributes) of
the parent process. The parent and child both have their own program
counter value and stack pointer, but all the test and data space is visible
to both proceses. This scheme provides one of the basic mechanisms upon
which parallel programs can be built.
Traditional POSIX threads are planned as a feature for general release on a future version of IRIX.
Parallel Development Environment
IRIX supports a wide variety of high-quality parallel compilers and tools
for both 32- and 64-bit applications development. The Fortran 77, C, and
C++ compilers support parallelization. Debuggers, profilers, and coverage
analyzers
are also optimized to support parallel code analysis.
File Services
The IRIX file subsystem supports multiple physical filesystems of different
file system types, and gives them the appearance of a single logical
filesystem with a hierarchical arrangement.
IRIX 6.1 uses the Virtual File System interface, known as the vnode interface.
The name vnode is derived from the name of the data structure used in the
interface. This interface was developed to facilitate the incorporation of
different filesystems. A de facto standard, the vnode interface is used by
third-party providers of filesystem technology, as with the enhanced
filesystem found in the Developer Magic Tracker product. It facilitates the
inclusion of several filesystem types into IRIX 6.1, including:
- XFS, our newest filesystem, discussed earlier
- EFS, our high-quality incumbent file system, now supplanted by XFS
- proc, which provides access to the image of each active process in the system. Both 64-bit and 32-bit /proc clients can operate and issue standard /proc ioctls. Additonal ioctls were added for 32-bit debuggers to support 64-bit clients
- NFS, the mount path on the server of the directory to be served via NFS
- ISO 9660, a file system type used to mount CD-ROM discs in High Sierra or ISO 9660 (with or without the Rock Ridge extensions) formats
- DOS: The file system driver supports 5.25-inch floppy drives in three standard formats when used with the freestanding SCSI floppy drive. The standard single and double density dual-sided 3.5-inch drive and the 3.5-inch 20.1MB floptical drive are also supported.
- swap, which can be either a file or block device to be used as a swap resource
I/O PERFORMANCE
IRIX 6.1 includes new interfaces that can be used in systems demanding the maximum possible I/O performance. These new features require source changes, but when used appropriately, the performance gains can be dramatic. These new features are:- asynchronous I/O
- memory-mapped I/O
- direct I/O
Traditionally, UNIX systems have allowed a given process to have only one I/O operation in progress at a time. This situation forced applications such as database servers that required several concurrent I/O operations to adopt complex, multiprocess architectures. IRIX 6.1 includes support for multiple concurrent I/O operations within a single process. The interfaces comply with the POSIX 1003.1b-1993 specification, allowing a user to queue read(2) and write(2) requests to a device, and receive an optional queued signal when the request completes. A process can simultaneously queue a number of requests without having to wait for any of them to complete. Since the interface is standards-compliant, applications using it are potentially portable between systems using the same interface.
Memory-Mapped I/O
IRIX 6.1 supports the SVR4 interfaces for memory-mapped I/O, which makes
disk files visible in the address space of the program, and makes them
accessible without explicit I/O operations. The kernel arranges to bring in
pages as it would for an executable, using the demand paging features of
the virtual memory subsystem.
mmap promises implementations that potentially operate more efficiently by avoiding the copying of bytes between user space and I/O buffers in the kernel. IRIX 6.1 supports the auxiliary operations for memory-mapped files as defined in SVID 3, such as control of copying modified pages back to the disk. Full support for memory-mapped I/O has required internal changes to the kernel virtual memory subsystem to support page level protection.
Direct I/O
Like memory-mapped I/O, direct I/O enables direct transfers between disk
and the user address space, bypassing the kernel buffer cache. Direct I/O
requires substantially fewer changes to an existing application than
memory-mapped I/O. Direct I/O requires that the program implement its own
read-ahead and write-behind policies. Using both direct and asynchronous
I/O, the program can have complete control of its own I/O operations,
yielding performance close to that of raw disk, while retaining the
benefits of the file system. The interfaces for direct I/O were defined by
Silicon Graphics.
EASE OF ADMINISTRATION
IRIX offers three different levels of administrative tools, aimed at users
with various needs and professional experience. Cadmin is a set of simple
visual tools for desktop users. IRIXpro is a suite of tools for system
administrators. Performance CoPilot is atool suite for network
administration.
Silicon Graphics also has developed swmgr, a graphical interface to inst and gendist, to ease software and patch installation, handle installation problems, and provide software version tracking.
A variety of ISVs, including Tivoli, Bull, CosMos/Computer Associates, Legent, and Raxco, sell system and network management solutions for Silicon Graphics platforms.
Cadmin
Cadmin is a simple visual system administration tool for software,
performance, volume, and file system management. Users can easily add
machines, new users, and simple devices, monitor status, and perform other
low-level, routine tasks.
IRIXpro
IRIXpro is a suite of tools for the professional systems administrator in
the technical computing market. The initial release of IRIXpro provides
four applications:
- Propel, rdist-based software and file distribution (integrated with swmgr)
- ProVision, a centralized SNMP-based system event monitoring tool
- Problema, a general-purpose help desk
- ProClaim, a network configuration server
Performance CoPilot is a Silicon Graphics tool suite that delivers distributed, integrated performance monitoring and performance management across a range of network platforms, databases, and applications. The product is targeted at performance analysts, developers, and system administrators.
Security
IRIX 6.1 incorporates technology originally developed for Trusted IRIX/B
for identification, authentication, and auditing. Shadow password support
places encrypted user passwords in a file that is inaccessible to
non-privileged programs, thwarting brute force attacks on the password data
base. Auditing logs security-relevant events, enabling analysis of attempts
at unauthorized entry and changes made to system files and configurations.
IRIX 6.1 also supports automatic password aging.
These features are designed to meet the U.S. Department of Defense "Orange Book" C2 level of trust.
Real-Time Features
IRIX 6.1 provides extensive support for the real-time facilities and
interfaces collectively referred to as REACT(TM). These allow the construction
of systems which interact with external events in a predictable controlled
manner. Application areas requiring deterministic latency include visual
simulation, where deterministic throughput applications include telemetry
and interactive television. The key elements of support for real time in
IRIX 6.1 include:
- Non-degrading priorities
- Deadline scheduling (discussed earlier)
- Facilities for locking pages in memory to avoid unpredictable delays caused by virtual memory page faults
- Bounded, dependable interrupt latencies, context switching times, and path lengths to interrupt handlers. The IRIX kernel has very fine-grained parallelism with preemption, resulting in excellent real-time interrupt response times.
- Predictable filesystem response. The XFS filesystem allows very efficient access to large data files, permits them to be pre-allocated in optimal layouts on the disk, and provides guaranteed rate I/O for deterministic throughput in multimedia and data collection applications.
IRIX 6.1 adds to this support the facilities for handling queued signals in accordance with POSIX 1003.1b-1993. Queued signals allow a collection of applications to be guaranteed to receive distinct signal events for every signal sent. Traditional UNIX signal could not guarantee this, so applications could not reliably count signals and trigger actions by their receipt.
These facilities allow IRIX, with its rich feature set and comprehensive applications support, to be used in many situations which require real-time environments. IRIX is much easier to use than some of the competitive real-time offerings, and has a much richer set of applications and software development features. These real-time, ease-of-use, and software development functionalities form the required foundation for exciting new products in the exciting new digital media and visual simulation arenas.
IRIX Support for Standards
IRIX 6.1 complies with the X/Open Portability Guide, Issue 3 (XPG3),
including support for Internationalization (I18N) and Localization (L10N).
XPG3 testing involves more than 5,200 distinct tests of exactly how the
system functions. These tests exercise the system to an unprecedented
degree, and contribute to the overall quality of the software when it is
released. XPG4 compliance testing is planned.
IRIX 6.1 also complies with the ABI described in the System V Interface Definition, Issue 3 (SVID3), the defining document for System V Release 4 (SVR4). Compliance with the SVR4 ABI is tested using a variety of commercial and public domain test packages. One of the most comprehensive of these is the Generic ABI Test Suite (gABI) developed by UNISOFT. The gABI is a comprehensive test of the compiance of the system consisting of more than 7,800 tests.
IRIX 6.1 will continue to meet the standards established by the POSIX 1003.1 Specification, which were first formally met by IRIX 4.0.5. IRIX 4.0.5 was certified by an independent test organization as complying with the FIPS 151-1 interpretation of P1003.1. IRIX 5.2 met the 1990 version of P1003.1, which corresponds to FIPS 151-2.
IRIX 6.1 incorporates SVR4 commands which are generally compliant with the POSIX 1003.2 Specifications. Marketplace demand for P1003.2 compliance has been modest, so full compliance will be deferred until future IRIX releases.
Internationalization (I18N) and Localization (L10N)
IRIX internationalization includes provision for user I/O from external
files (for easy translation into local languages), localizeable numeric
formats, and support for large (e.g. Asian and Arabic) characters.
Silicon Graphics country kits take advantage of these features to provide
localized interfaces for each country: translation of user input and
output, and numerical display according with local preferences.
COMPATIBILITY
Binary Compatibility Between IRIX 5.3 and IRIX 6.1
Nearly all binaries built on IRIX 5 can be run under IRIX 6. There may be
rare cases in which application code must be recompiled or recoded to take
advantage of IRIX 6 enhancements.,
Object Compatibility Between IRIX 6.0.1 and IRIX 6.1
User object code is compatable betw,een IRIX 6.0.1 and IRIX 6.1, however,
device drivers must be recompiled.