Mathematical Acceleration Subsystem (MASS)

MASS Version 3.0


For questions, contact write to:

	MASS Program Manager (Mail Stop 904-3E018)
	IBM Austin Laboratory
	11400 Burnet Road
	Austin, TX 78758-3406


MASS consists of libraries of tuned mathematical intrinsic functions. Each new MASS version includes the material from previous versions that has not been changed, except that Version 3.0 no longer includes the library that runs only on POWER2 processors. The POWER2 library remains available in Version 2.7 of MASS.

Version 1.0
Version 1.0 of MASS introduced a library of mathematical intrinsic functions, libmass.a, that offered tuned alternatives for functions in libm.a, the math library supplied with AIX.
Version 2.1
Version 2.1 of MASS added two new libraries of vector function subroutines, libmassv.a for general use and libmassvp2.a for use only on POWER2 machines.
These vector subroutines compute result vectors as functions of their argument vectors. The scalar library libmass.a was unchanged.
Version 2.2
Version 2.2 added functions to the vector libraries.
Version 2.3
Version 2.3 included improved scalar sqrt and rsqrt functions, added more vector functions, and introduced a Fortran/C source library of simple implementations of the functions in the MASS vector libraries. This permits users who vectorize their programs to have portable code. The performance and accuracy tables were considerably revised and extended as well.
Version 2.4
Version 2.4 added a tanh intrinsic function to the scalar library and slightly improved the sinh and x**y functions. Short-precision vector functions and vector atan2 were added to the general vector library.
Version 2.5
Version 2.5 makes the general vector library, libmassv.a, safe for multi-threaded applications where MASS functions might be called by two threads simultaneously (threadsafe). Some of these vector functions were further tuned. A new POWER3 vector library, libmassvp3.a (also threadsafe), is added, with some routines tuned for the POWER3 architecture as implemented on the 630 processor (the remaining routines being unchanged from the general vector library). A dnint routine was added to the scalar library, libmass.a. The functions unique to the POWER2 vector library, libmassvp2.a, are unchanged.
Version 2.6
Version 2.6 makes the scalar library, libmass.a, safe for multi-threaded applications where MASS functions might be called by two threads simultaneously (threadsafe). The scalar library shows only minor changes in performance.
Version 2.7
Version 2.7 replaces twelve functions (forms of exp, log, sin, and cos) in the general vector library, libmassv.a, with versions that have been rewritten for better short-precision performance and better performance for the POWER3 architecture as implemented on the 630 processor. The architecture-specific vector libraries, libmassvp2.a and libmassvp3.a, also include the new functions.
Version 3.0
Version 3.0 augments the existing libmass.a, libmassv.a, and libmassvp3.a libraries with 64-bit versions of all functions, except vatan2 and vsatan2. The MASS libraries will now link to 32-bit or 64-bit applications. Version 3.0 supports two platforms, AIX Version 4.3 or later and AIX Version 5, using separate installations. Using the correct set of MASS libraries is necessary because of differences in the platforms. Version 3.0 adds a new POWER4 vector library, libmassvp4.a, that includes implementations of the vdiv, vsdiv, vrec, and vsrec functions that have been tuned for the POWER4 processors.

Scalar Library

The MASS scalar library, libmass.a, contains an accelerated set of frequently used math intrinsic functions in the AIX system library libm.a (now called libxlf90.a in the IBM XL Fortran manual):

  • sqrt, rsqrt, exp, log, sin, cos, tan, atan, atan2, sinh, cosh, tanh, dnint, x**y

The libmass.a library can be used with either Fortran or C applications and will run under AIX on all of the IBM pSeries and RS/6000 processors. Because MASS does not check its environment, it must be called with the IEEE rounding mode set to round-to-nearest and with exceptions masked off (the default XLF environment). MASS may not work properly with other settings. In some cases MASS is not as accurate as the system library, and it may handle edge cases differently from libm.a (sqrt(inf), for example). The trig functions (sin, cos, tan) return NaN (Not-a-Number) for large arguments (abs(x)>2**50*pi). In Version 2.4 the x**y function was revised to accept negative x arguments with integer y arguments according to the C standard. (The Fortran standard prohibits such arguments, and the function previously returned NaNs for them.)

Vector Libraries

The general vector library, libmassv.a, contains vector functions that will run on the entire IBM pSeries and RS/6000 families. The library libmassvp3.a contains the functions of libmassv.a, including some that have been tuned for the POWER3 architecture used by the 630 processor. The library libmassvp4.a also contains the functions of libmassv.a, including some that have been tuned for the POWER4 processors. The performance tables in the following sections list the contents of the vector libraries.

The vector libraries libmassv.a, libmassvp3.a, and libmassvp4.a can be used with either FORTRAN or C applications. When calling the library functions from C, only call by reference is supported, even for scalar arguments. As with the scalar functions, the vector functions must be called with the IEEE rounding mode set to round-to-nearest and with exceptions masked off. The accuracy of the vector functions is comparable to that of the corresponding scalar functions in libmass.a, though results may not be bit-wise identical.

The MASS vector Fortran source library enables application developers to write portable vector codes. The source library, libmassv.f, includes Fortran versions of all the vector functions in the MASS vector libraries. The following performance tables show that performance improvements are possible even when the MASS scalar functions are used in the vector loops of libmassv.f.

Performance and Accuracy Information for the MASS Libraries

The following table provides approximate performance data for the MASS scalar library running on the 604E (PowerPC), 630 (POWER3), and POWER4 processors. The data was obtained by timing many repetitions of a loop over 1,000 random arguments and includes all overheads. Timing in this way will bring the input and output vectors into the on-chip cache (because the loop is short enough for the vectors to fit in the cache). Performance may deteriorate seriously when the input and output vectors are not in the cache. Performance may also deteriorate for arguments at or near the end-points of the valid argument ranges. The 630 and POWER4 processors have a hardware square root that is not timed here. The libxlf90.a measurements were made with the versions of the library available on the respective test systems. They may vary from the versions timed for previous versions of MASS. Users may experience performance that differs from that found in this table.

  Math function performance (cycles per call, length 1000 loop)

                  libxlf90.a       libmass.a         ratio
Function Range  604E  630 POW4  604E  630  POW4  604E  630 POW4
  sqrt     A      68   59* 125*   50   45*  72*  1.36 1.31 1.74
 rsqrt     A      80   71* 121*   52   53*  75*  1.54 1.34 1.61
   exp     D      87   64   89    42   27   42   2.07 2.37 2.12
   log     C     100   87  167    55   53   84   1.82 1.64 1.99
   sin     B      51   36   54    27   15   24   1.89 2.40 2.25
   sin     D      79   60   73    60   42   69   1.32 1.43 1.06
   cos     B      52   37   53    26   15   23   2.00 2.47 2.30
   cos     D      76   58   76    59   42   69   1.29 1.38 1.10
   tan     D     137  113  178    76   42   73   1.80 2.69 2.44
  atan     B      60   52   54    53   45   55   1.13 1.16 0.98
  atan     D      97   70   96    86   58   91   1.13 1.21 1.05
  sinh     D     218  186  279    61   44   67   3.57 4.23 4.16
  cosh     D     154  120  207    49   34   53   3.14 3.53 3.91
  tanh     D     217  206  291    78   53   82   2.78 3.89 4.30
 dnint     D      36   24   37    22   12   35   1.64 2.00 3.51
 atan2     B     538  410  798   106   88  137   5.08 4.66 5.82
  x**y     C     287  228  405   114   97  183   2.52 2.35 2.21

 *  When this function is compiled specifically for this processor,
inline code using the optional sqrt instruction will be generated.
This is not what is being timed here.

   Range Key     Processor     Cycle time      D-cache
 A =    0,  1        604E    3.0  nanoseconds    32k
 B =   -1,  1         630    5.0  nanoseconds    64k
 C =    0,100      POWER4    0.77 nanoseconds    32k
 D = -100,100

The following table lists estimates of the number of processor cycles per evaluation of a vector element for the various MASS vector libraries. The estimates used vectors of length 1000 so that the caches contain all the vectors. The columns labeled libm give the results from using the functions in the MASS Fortran source code library libmassv.f (see The Vector Libraries)to call the functions in libxlf90.a. The Fortran source code was compiled with the IBM XLF compiler using the -O option. The columns labeled mass show results of the same process, except for using libmass.a instead of libxlf90.a. The columns labeled massv, vp3, and vp4 list the results obtained with the libraries libmassv.a, libmassvp3.a, and libmassvp4.a, respectively. Times are not given for functions in the libmassvp3 and libmassvp4 libraries that are identical to the functions in the libmassv library. The results were measured on PowerPC, POWER3, and POWER4 systems.

Results will vary with vector length. Entries in the table where the library function does not exist or where the measurement was not done are blank.

    Math Library Performance (cycles per evaluation, length 1000 loop)

                     604E                630		    POWER4
  function range libm mass massv libm mass massv vp3  libm mass massv vp4
     vrec    D     32*       10     9*        6  4.2    15*       12  5.4
    vsrec    D     18*        8     7*        5  2.6    15*        8  3.9**
     vdiv    D     32*       12     9*        7  5.0    15*       14  6.4
    vsdiv    D     18*       10     7*        6  3.2    15*       10  4.7**
    vsqrt    C     67   48   16    11*        9  6.4    18*       17   18
   vssqrt    C     70   48   10     7*        8  4.6    18*       12    8
   vrsqrt    C     79   49   16    22*        9  6.0    32*       19   13
  vsrsqrt    C     83   51    9    16*        7  4.2    32*       11    6
     vexp    D     83   45   18    64   33    6         88   41   14
    vsexp    D     85   44   18    68   36    5         94   43   10
     vlog    C     99   56   21    83   53    8        148   84   15
    vslog    C    102   56   22    86   57    7        148   90   12
     vsin    B     50   29   11    36   16    5         53   23    7
     vsin    D     79   59   27    60   43   12         74   68   20
    vssin    B     51   26   12    39   18    4         55   25    5
    vssin    D     79   58   28    62   46    9         78   71   16
     vcos    B     51   26   10    37   16    4         57   23    7
     vcos    D     75   59   27    58   43   12         76   68   20
    vscos    B     52   26   11    39   18    3         58   26    5
    vscos    D     76   59   29    61   46    9         78   71   16
  vsincos    B    100   53   20    80   33    8        101   48   13
  vsincos    D    151  116   29   123   92   12        146  133   22
 vssincos    B    107   55   21    79   38    6        105   52   10
 vssincos    D    159  118   31   125   98   10        153  134   18
 vcosisin    B    104   55   20    78   34    8        108   48   12
 vcosisin    D    156  118   29   123   93   12        150  132   21
vscosisin    B    108   55   21    79   36    6        109   50   10
vscosisin    D    160  119   31   125   95    9        155  134   18
     vtan    D    136   74   32   111   52   19        188   70   37
    vstan    D    136   74   32   113   56   19        198   75   37
   vatan2    D    545  104   40   413   87   25        737  138   49
  vsatan2    D    545  104   40   418   89   25        738  141   48
   vdnint    D     37   22    7    24   12  3.4         35   35    7
    vdint    D     36         6    22       2.8         37         9

  * indicates inline instructions timed (not a subroutine call)
 ** indicates a timing that is no longer valid (update pending)

  Range Key      Processor     Cycle time         D-cache size
  A =    0,  1      604E    3.0  nanoseconds      32 kilobytes
  B =   -1,  1       630    5.0  nanoseconds      64 kilobytes
  C =    0,100    POWER4    0.77 nanoseconds      32 kilobytes
  D = -100,100
  E =  -10, 10

Short-precision versions of the vector functions vexp through vatan2 are now included in libmassv.a. They are obtained when the prefix is vs rather than just v.

The following table provides sample accuracy data for the libm, libmass, libmassv, libmassvp3, and libmassvp4 libraries. The numbers are based on the results for 10,000 random arguments chosen in the specified ranges. Real*16 functions were used to compute the errors. There may be portions of the valid input argument range for which accuracy is not as good as illustrated in the table. Also, accuracies may vary from values in the table when argument values are used that are not represented in the table.

The entries in the percent correctly rounded (PCR) column are obtained by counting the number of correctly rounded results out of the 10,000 samples with random argument. A result is correctly rounded when the function returns the IEEE 64-bit value that is closest to the exact (infinite-precision) result.

                        Math Library Accuracy

                       libm         libmass       libmassv
function range     PCR     MaxE   PCR     MaxE   PCR     MaxE
   rec     D      100.00*   .50*                100.00    .50
  srec     D      100.00*   .50*                 92.47    .66
   div     D      100.00*   .50*                 74.21   1.28
  sdiv     D      100.00*   .50*                100.00    .50
  sqrt     A      100.00    .50   96.59    .58   96.42    .60
 ssqrt     A      100.00    .50  100.00    .50   87.64    .79
 rsqrt     A       88.52    .98   98.60    .54   97.32    .62
srsqrt     A      100.00    .50  100.00    .50   86.39    .82
   exp     D       99.95    .50   96.55    .63   96.58    .63
  sexp     E      100.00    .50  100.00    .50   98.87    .52
   log     C       99.99    .50   99.69    .53   99.69    .53
  slog     C      100.00    .50  100.00    .50   99.91    .51
   sin     B       81.31    .91   96.88    .80   97.28    .72
   sin     D       86.03    .94   83.88   1.36   83.85   1.27
  ssin     B      100.00    .50  100.00    .50   99.95    .50
  ssin     D      100.00    .50  100.00    .50   99.73    .51
   cos     B       92.95   1.02   92.20   1.00   93.19    .88
   cos     D       86.86    .93   84.19   1.33   84.37   1.33
  scos     B      100.00    .50  100.00    .50   99.35    .51
  scos     D      100.00    .50  100.00    .50   99.82    .51
   tan     D       99.58    .53   64.51   2.35   50.48   3.19
  stan     D      100.00    .50  100.00    .50  100.00    .50
 atan2     D       74.66   1.59   88.02   1.69   84.01   1.67
satan2     D      100.00    .50  100.00    .50  100.00    .50
  atan     B       99.82    .51   92.58   1.78
  atan     D       99.98    .50   98.86   1.72
  sinh     D       94.78   1.47   89.54   1.45
  cosh     D       95.64    .97   92.73   1.04
  tanh     E       94.08   2.95   83.33   1.79
  X**Y     C       99.95    .50   96.87    .62

                       libm        libmassvp3     libmassvp4
function range     PCR     MaxE   PCR     MaxE   PCR     MaxE
   rec     D      100.00*   .50* 100.00    .50   98.00    .61
  srec     D      100.00*   .50*  99.97    .50  100.00    .50
   div     D      100.00*   .50*  74.21   1.28   73.52   1.45
  sdiv     D      100.00*   .50*  74.49   1.31   74.36   1.46
  sqrt     A      100.00    .50   63.14   2.16
 ssqrt     A      100.00    .50   87.05    .83
 rsqrt     A       88.52    .98   82.00   1.22
srsqrt     A      100.00    .50   89.66    .86

         * indicates hardware instruction was used

  Range Key        PCR  = Percentage correctly rounded
  A =    0,  1     MaxE = Maximum observed error in ulps
  B =   -1,  1
  C =    0,100
  D = -100,100
  E = - 10, 10

Installing the Libraries

MASS consists of eight files (LICENSE, MASS.readme, libmass.a, libmassv.a, libmassvp3.a, libmassvp4.a, libmassv.f, and massv.h) packaged as a compressed tar file, MASS_VN.tar.Z, where VN denotes the version number (for instance, 3.0_aix5). The installation procedure for MASS depends on whether the installer has root access on the target system. If the installer has root access, follow the instructions for installing as root.Otherwise, follow the instructions for installing as non-root user.

MASS is more convenient to use when it is installed with root access and linked to the conventional /usr/lib directory because the shorthand -lmass flags can be used instead of specifying an explicit path for the libraries.

The tar file will create a mass subdirectory in the current directory because it uses relative file names.

Installing as Root

  1. login as root
    -- or --
    su to root

  2. cd /usr/lpp

    MASS files will be restored to the directory /usr/lpp/mass.

  3. zcat /tmp/MASS_VN.tar.Z | tar -xvf -
    -- or --
    uncompress /tmp/MASS_VN.tar.Z
    tar -xvf /tmp/MASS_VN.tar

  4. ln -s /usr/lpp/mass/libmass.a /usr/lib/libmass.a
    ln -s /usr/lpp/mass/libmassv.a /usr/lib/libmassv.a
    ln -s /usr/lpp/mass/libmassvp3.a /usr/lib/libmassvp3.a
    ln -s /usr/lpp/mass/libmassvp4.a /usr/lib/libmassvp4.a

    (This step creates a symbolic link from the /usr/lpp/mass/libmass.a to /usr/lib/libmass.a etc. so that users can specify a flag, such as -lmass, to link MASS libraries.)

Applications can now be linked by any user simply by using the correct flag. For instance,

    cc -o foo foo.c -lmass -lm ...  (for scalar only)
    cc -o foo foo.c -lmassv -lm ... (for vector only)
    cc -o foo foo.c -lmassvp3 -lm ... (for POWER3 vector only)
    cc -o foo foo.c -lmass -lmassv -lm (for scalar and vector)
    cc -o foo foo.c -lmass -lmassvp3 -lm (for POWER3 scalar and vector)

Installing as Non-Root User

  1. cd to the directory where the MASS subdirectory should be created

  2. zcat /tmp/MASS_VN.tar.Z | tar -xvf -
    -- or --
    uncompress /tmp/MASS_VN.tar.Z
    tar -xvf /tmp/MASS_VN.tar

Applications can be now linked with libmass.a by using the -L flag to specify the directory in which the MASS libraries reside. For instance, if MASS was installed in /home/somebody/mass, then any user with read access to that directory can link applications in the following manner:

    cc -o foo foo.c -L /home/somebody/mass -lmass -lm ...

Note for Worldwide Web Users

Some Web browsers will uncompress the tar file before storing. If the previous instructions result in the error message:

    MASS_VN.tar.Z: not in compressed format

then try the following:

    mv MASS_VN.tar.Z to MASS_VN.tar
    tar -xvf /tmp/MASS_VN.tar

The MASS Fortran Source File. Successfully installing MASS also creates in the mass directory the file libmassv.f, a Fortran source file of simple loops for the MASS vector functions. The section on the vector libraries describes its use.

Using the MASS Libraries

The Scalar Library

To use libmass.a, use -lmass before libm.a or libxlf90.a in the linker command line. We will use libm.a in the following examples. For example, if the library is installed in the standard directory /usr/lib, the command lines for Fortran and C would be:

    xlf progf.f -o progf -lmass
    cc progc.c -o progf -lmass -lm

If libmass.a is installed in a directory other than in /usr/lib, such as in /home/somebody/mass, use the -L option to add that directory to the library search path:

    xlf progf.f -o progf -L/home/somebody/mass -lmass
    cc progc.c -o progf -L/home/somebody/mass -lmass -lm

(Fortran links with libm.a automatically, so only -lmass need to be specified on the command line. For C code, the link command must specify both libmass.a and libm.a because libmass.a includes only a subset of the functions in libm.a.). The library uses some global names for shared tables. The global names have the form %...$.

When called from C code, the functions in libmass.a will not set the global variable errno to indicate range, domain, or loss of precision errors. For instance, with libm.a sqrt(-1) will return the value NaN (not a number) and will set errno to 33 (EDOM -- domain error); with libmass.a sqrt(-1) simply returns NaN but does not set errno.

The XLF compiler handles the rsqrt function in a different way from the other intrinsic functions. The XLF manuals discuss the special handling of rsqrt.

Selective Use of libmass.a

If you wish to use libmass.a for some functions and the normal libm.a for the remainder, you can use an export list with the ld command. For instance, to select only the fast tangent routine from libmass.a for use with the C program sample.c:

  1. Create an export list containing the names of the desired functions. In this case, the file export.list will contain only two lines:
    (Remember that Fortran names start with "._", while C names start with ".")

  2. Pull the exported routines into an object file using the load command with libmass.a.
        ld -o fast_tan.o  -bE:export.list -lmass
    (or, if libmass.a is not in /usr/lib)
        ld -o fast_tan.o -bE:export.list -L/some/other/path -lmass
    (or, if you would like the 64-bit versions of the exported functions)
        ld -o fast_tan.o -b64 -bE:export.list -lmass

  3. Create the final executable using cc, specifying fast_tan.o before the standard math library, libm.a. This will link only the tan routine from MASS (now in fast_tan.o) and the remainder of the math subroutines from the standard system library:
        cc -o sample fast_tan.o -lm

(Note: this scheme will work for all routines in libmass.a except sin, cos, atan, and atan2. These routines are coded together, so selecting fast sin will also link in fast cos; selecting atan will also link atan2.)

The Vector Libraries

Successful use of the MASS vector libraries is contingent on the user vectorizing the application. To assist in that effort, the Fortran source library libmassv.f has been provided for use on non-IBM systems where the MASS libraries are not available. The syntax for the vector functions is visible in libmassv.f, and the user can write code using these functions to obtain code that may port to systems other than the pSeries and RS/6000 systems. The user can then use the faster MASS vector libraries with that same code when running on a pSeries or RS/6000 system. See the section on Vector Code Portabilityfor more details.

To use the faster MASS libraries in an application that has been vectorized, simply use the corresponding library name or names in the linker command line. For instance, when the library is installed in the standard directory /usr/lib, the command lines for Fortran and C would be:

    xlf progf.f -o progf -lmassv
    cc progc.c -o progf -lmassv -lm

If libmassv.a is installed in a directory other than /usr/lib, such as in /home/somebody/mass, use the -L option to add that directory to the library search path:

    xlf progf.f -o progf -L/home/somebody/mass -lmassv
    cc progc.c -o progf -L/home/somebody/mass -lmassv -lm

The vector function subroutines may be used as any Fortran function subroutines via a CALL statement, using the same syntax as the functions in libmassv.f. Except for vdiv, vsincos, vcosisin, vatan2, vdfloat, vidint, and vdsign, the functions in libmassv.a, libmassvp3.a, and libmassvp4.a are all of the form function_name (y,x,n), where x is the source vector, y is the target vector, and n is the vector length. The arguments y and x are assumed to be long-precision (real*8) for functions whose prefix is v, and short-precision (real*4) for functions with prefix vs. The three-argument subroutines are all used in the same way. For example:

    DIMENSION X(500),Y(500)
    CALL VEXP(Y,X,500)

returns a vector Y of length 500 whose elements are exp(X(I)); I=1,500.

The functions vdiv, vsincos, vatan2, and vdsign are of the form function_name(x,y,z,n). Vdiv returns a vector x whose elements are y(I)/z(I), I=1,n. Vsincos returns two vectors, x and y, whose elements are sin(z(I)) and cos(z(I)) respectively. Vatan2 returns a vector x whose elements are atan(y(I)/z(I)) respectively. Vdsign returns a vector x of elements of the form dsign(y(I),z(I)). Arguments follow the same conventions as given previously.

In vcosisin(y,x,n), x is a vector of n real*8 elements and the function returns a vector y of n complex*16 elements of the form (cos(x(I)),sin(x(I))).

In vdfloat(y,l,n) and vidint(l,x,n), x and y are vectors of n real*8 elements and and l is a vector of n integer*4 elements. Vdfloat returns a vector of elements of the of the form dfloat(l(I)). Vidint returns a vector of elements of the form idint(x(I)).

When calling the vector functions from C, only call by reference is supported, even for scalar arguments.

Vector Code Portability

The recommended procedure for writing a portable code that is vectorized for using the fast MASS vector libraries, is to write in ANSI standard language and use the vector functions defined by libmassv.f. Then, to prepare to run on a system other than an IBM pSeries or RS/6000 system, compile the application source code together with the libmassv.f source. The vector syntax to be used is visible in the libmassv.f source. Commenting out one line of the vrsqrt subroutine, which is a directive to the IBM XLF compiler, may be necessary for full portability.

When running the application on an IBM pSeries or RS/6000 system, the faster MASS vector libraries can be linked as described previously.

WARNING: Do not use libmassv.f on IBM pSeries and RS/6000 systems. Use the -lmassv flag instead. The libmassv.f Fortran source vector library should be used as a portable substitute for the MASS vector libraries only on non-IBM systems.

Obtaining MASS: License and Download

The routines in MASS Version 3.0 are made available at no additional charge to users on the worldwide Web under the terms and conditions that follow. They are not licensed for resale with vendor applications. For distribution with vendor applications, please see the DEVCON AIX developers disk and its accompanying license, which can be found at

By downloading MASS Version 3.0 you agree to the following:

MASS Version 3.0 is licensed to you under the terms and conditions of your AIX license with IBM, and the following additional provisions: Notwithstanding anything to the contrary contained in your AIX license, MASS is provided to you AS IS. IBM MAKES NO WARRANTIES, EXPRESSED OR IMPLIED, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IBM has no obligation to defend or indemnify against any claim of infringement, including, but not limited to, patents, copyright, trade secret, or intellectual property rights of any kind.

Select one of the following installations to obtain a MASS Version 3.0 license and download the files:

Obtaining Previous MASS Versions

The following back-level versions of MASS are also available: