Last updated: January 13, 1996

MINT (MIPS Interpreter) is a fast program-driven simulator for
multiprocessor systems. The abstract as given in the "MINT Tutorial
and User Manual" is as follows:

    This document describes MINT, a software package designed to
    ease the process of constructing event-driven memory hierarchy
    simulators for multiprocessors. It provides a set of simulated
    processors that run standard Unix executable files compiled for
    a MIPS R3000 based multiprocessor. These generate multiple
    streams of memory reference events that drive a user-provided
    memory system simulator. MINT uses a novel hybrid technique
    that exploits the best aspects of native execution and software
    interpretation to minimize the overhead of processor simulation.
    Combined with related techniques to improve performance, this
    approach makes simulation on uniprocessor hosts extremely efficient.

MINT runs on Silicon Graphics computers and DECstations and interprets
MIPS R3000 instructions. MINT also runs on a SPARC and interprets
MIPS code, not SPARC code. MINT has not yet been ported to any other
machine.

To build MINT, follow the steps below.

1. Run the "config.sh" script.
   This will install the machine-dependent makefiles in the "src/"
   and "examples/" directories.

2. (Optional) Edit "src/Makefile" to set the INSTALL_DIR variable
   to wherever you want. The default is the directory containing
   this "README" file.

3. Type "make".
   This will build the mint objects and libraries under the "src/"
   directory for both the optimized and debugging versions of MINT. It
   will also build the examples in the "examples/" directory.

   This will also compile the programs in the "Tests" directory, unless
   you are building on a Sparc. The Sparc version of MINT requires that
   the programs in the "Tests" directory be built on an SGI machine.

   An executable called "mint" will also be created. This is mint.o linked
   with the default simulator functions (most of which simply return)
   provided in libsim.a.

   The "debug version" of MINT can be used with dbx. This version enables
   more runtime checks, and is useful when developing a back-end simulator.
   The objects mintd.o and libdsim.a should be used instead of mint.o and
   libsim.a when building your back-end simulator.

4. The directory "src/Tests" contains some programs to test the instruction
   interpretation of MINT. These programs are compiled by the "make" in
   step 3. To run the tests, type (assuming you are in the "src" directory):

   mint Tests/alu
   mint Tests/fpu

   Each program prints lots of lines of output, and if all the tests passed,
   they print:

   All tests passed.

5. There are simple examples that demonstrate how to link with and use MINT
   in the "examples" directory. The "doc" directory contains the "MINT
   Tutorial and User Manual" in the file "main.ps".

6. To create (or re-create) only the debugging version of MINT type (in
   the "src/" directory):

   make clean
   make debug
   make debug-install

   or 

   make clean
   make debug DEFS=-DTRACE
   make debug-install

   This will create a "mintd.o" and a "libdsim.a" that you can link
   with. This version uses function calls instead of inline macros,
   and includes some support for debugging by keeping a history of
   recently executed instructions. (You also must define "TRACE" when
   compiling to get the history trace. You can print out the history by
   calling the function "trace_print(numlines)" from within a debugger.
   See the file "exec.c".) The debugging version also uses a C function
   for the scheduler instead of an equivalent (but optimized) assembly
   language routine. While developing a back-end simulator, it is
   useful to link with the debugging version since it has some extra
   consistency checks.

Note for DECstation users:
   If you try to compile programs that use the Argonne p4 macros
   (such as the SPLASH programs) the compile may fail because you
   are using SGI macros on a DECstation and some functions won't
   be in the system libraries. To create an executable in this case,
   link the programs with the "stub" library provided with MINT by
   using "-lstub". This library has empty function definitions to
   satisfy the linker. The fully linked executable won't run natively
   but you can use MINT to simulate it.
      Note that it does not work to compile a program on an SGI and
   then try to use MINT on a DECstation to simulate it. The two systems
   use different endian-ness so the data section is all garbled.
      Since the DECstation usually has less memory than an SGI, you
   may want to edit "globals.h" (before compiling MINT) to change the
   default size of the memory segments that are allocated. The default
   shared memory segment size is defined by "SHMEM_SIZE" and the default
   private memory size is defined by the sum of the space for the
   data + bss + heap + stack. The default heap and stack sizes are
   controlled by the constants "HEAP_SIZE" and "STACK_SIZE".

Note for SPARC users:
   MINT runs on a SPARC but does not simulate applications compiled for
   a SPARC. The applications must be compiled for the MIPS instruction
   set. This can be done by compiling on an SGI. It may also be
   possible to use gcc to cross-compile for the SGI on a SPARC but I
   haven't tried this. Compiling an application on a DECstation does
   not work. This is because DECstations are little-endian and SPARCs
   are big-endian.
      Some Sparcs have a problem with allocating a shared memory
   segment at a specified address. The shmat() call fails silently
   and when MINT tries to write the shared memory segment, it gets
   a segmentation violation. When I have time, I'll work on a solution
   to this. For a work-around, you can try changing the address at which
   the shared segments are placed. Edit the file "globals.h" and change
   the variables "SHARED_START" and "PRIVATE_START".
      Installation instructions on a SPARC: the files in the src/Tests/
   directory are tests that contain MIPS assembly language in order
   to test that the MINT simulator compiled on the SPARC is correct.
   The Makefile avoids compiling these files when you build MINT on the
   SPARC, but you will not be able to run the tests until you compile
   the files on an SGI.

R4000 support:
   Although there is support for some R4000 instructions, it is not
   complete. The ll, sc, and sync instructions have been added as well
   as the various branch instructions.  The 64-bit loads and stores are
   not supported, and in fact all registers are assumed to be 32 bits.
   Support for hardware interlocking (where instructions may continue
   executing after a load as long as they do not use a register that is
   the target of a load) is not complete yet.

Missing features:
   MINT supports most Unix system calls but not all. If an object
   program attempts to make an unsupported system call, MINT will
   report the system call number and exit. Unix features that are
   not supported include (not an exhaustive list):
       System V messages, and exec(), and mmap()

   Most system calls are not difficult to add, but they have not been
   used in the parallel programs I've seen. In particular, none of the
   programs in the Splash suite require these features.

SVR4 ELF support:
   MINT now understands ELF as well as COFF object files, but applications
   that use ELF must be *statically* linked (dynamic shared libraries
   are not supported). To create a statically linked object file, use
   the "-non_shared" option to the C compiler.

If you get a copy of MINT, please send your email address to me at
veenstra@sgi.com so I can send you notifications of bug fixes and new
releases.

To cite MINT in a publication, please use the following reference.
In "bibtex" format:

@inproceedings{VeenstraFowler94,
author =        "Jack E. Veenstra and Robert J. Fowler",
title =         "{MINT}: A Front End for Efficient Simulation of Shared-Memory
Multiprocessors",
booktitle =     "Proceedings of the Second International Workshop on Modeling,
Analysis, and Simulation of Computer and Telecommunication Systems (MASCOTS)",
pages =         "201-207",
year =          "1994",
mon =           jan
}

In "lookbib" format:

%A Jack E. Veenstra
%A Robert J. Fowler
%T MINT: A Front End for Efficient Simulation of Shared-Memory Multiprocessors
%J PROC of the Second INTL Workshop on Modeling, Analysis and Simulation of
Computer and Telecommunication Systems (MASCOTS '94)
%P 201-207
%D January\|\(mi\|February 1994
%X 31 January\|\(mi\|2 February 1994
%C Durham, NC


Jack Veenstra
veenstra@sgi.com
http://reality.sgi.com/employees/veenstra_mti