Difference between revisions of "Compiling M5"

Revision as of 13:03, 18 August 2006

M5 runs on Linux, Mac OS X and OpenBSD, but should be easily portable to other Unix-like OSes. Cross-endian support has been mostly added, however this has not been extensively tested. All the syscall emulation (_SE) targets support running regardless of host/target endianess, however at present ALPHA_FS does not fully support big endian machines.

Required Software

To build M5, you will need the following software:

• g++ version 3.4 or newer. Once upon a time, M5 built with g++ 2.95, but it probably doesn't anymore; < 3.4 seems to have some issues with templates.
• Python, version 2.4 or newer.
• SCons, version 0.96.91 or newer.
• SWIG, version 1.3.28 or newer.

SCons is a powerful replacement for make. See here to download SCons. If you do not have administrator privileges on the machine you are trying to compile on, you can use the "scons-local" package to install scons in your m5 directory, or install SCons in your home directory using the '--prefix=' option.

There a few utility scripts written in Perl, but Perl is not necessary to build or run the simulator.

Possible Targets

M5 can build many binaries each for a different guest architecture, simulation mode, and use. The currently available architectures are ALPHA, SPARC, and MIPS.

Each of these can built in two simulation modes:

• FS - Full System mode. This mode simulates a complete system including a kernel, I/O devices, etc. This mode currently only works with the ALPHA architecture.
• SE - Syscall Emulation mode. This mode simulates statically compiled binaries by functionally emulating any syscall they make.

For each possible architecture and mode, several different executables can be built:

• m5.debug - A binary used for debugging without any optimizations. Since no optimizations are done this binary is compiled the fastest, however since no optimizations are done it executes very slowly. (-g3 -gdwarf-2 -O0).
• m5.opt - A binary with debugging and optimization. This binary executes much faster than the debug binary and still provides all the debugging facility of the debug version. However when debugging source code it can be more difficult to use that the debug target. (-g -O3)
• m5.prof - This binary is like the opt target, however it also includes profiling support suitable for use with gprof. (-O3 -g -pg).
• m5.fast - This binary is the fastest binary and all debugging support is removed from the binary (including trace support). (-O3 -DNDEBUG)

Source Tree

Once you have obtained and unpacked the M5 sources, the root of your of your M5 source tree should have three directories:

• build_opts - Default build options for each target (e.g., what set of build flags does the ALPHA_FS target imply)
• configs - Sample script files that can be used to run M5 and as a starting place for your own configurations
• ext - External packages used by M5 that are not commonly installed on systems
• src - Source code for the simulator itself
  • arch - Architecture specific files as well as the ISA parsing code
    • alpha - Files specific to the Alpha architecture
      • freebsd - Files specific to the Alpha architecture and to the FreeBSD operating system
      • isa - ISA description files for the Alpha architecture
      • linux - Files specific to the Alpha architecture and to the Linux operating system
      • tru64 - Files specific to the Alpha architecture and to the Tru64 operating system
    • mips - Files specific to the MIPS architecture
      • isa - ISA description files for the MIPS architecture
      • linux - Files specific to the MIPS
    • sparc - Files specific to the SPARC architecture
      • isa - ISA description files for the SPARC architecture
      • linux - Files specific to the SPARC architecture and to the Linux operating system
      • solaris - Files specific to the SPARC architecture and to the Linux operating system
  • base - General data structures and facilities that could be useful for another project
    • loader - Code for loading binaries and reading symbol tables
    • stats - Code for keeping statistics and writing the data to a file or a database
  • cpu - CPU models for the simulator
  • dev - I/O device models for the simulator
  • docs - Doxygen templates & output
  • encumbered - Code that has a different, more restrictive license than M5's
  • kern - Operating system but architecture independent code (e.g. types of data structures).
    • linux - Linux specific architecture independent code
    • solaris -Solaris specific architecture independent code
    • tru64 - Tru64 specific architecture independent code
  • mem - Models for the memory system
  • python - Python code for configuration and higher level functions
  • sim - Simulator specific base functionality
• system - This directory contains platform dependent code such as BIOS, hypervisor, that someone using M5 may want to modify.
  • alpha - Alpha console and palcode
  • mips - none yet
  • sparc - none yet
• tests - Regression test framework
  • configs - Test configurations
  • test-progs - Binaries and inputs for test programs
  • quick, medium, long - Actual regression tests, including reference ouputs, grouped by runtime
• util - Random programs that are used in conjunction with M5 such as Python scripts to process data in an DB, submit jobs to a batch processing system, etc.

Compiling

Starting in the root of this tree, you can build M5 using a command of the form:

% scons build/<arch>_<type>/m5.<binary>

where the items between <> are the architectures, types and binaries listed above. For example:

% cd m5
% scons build/ALPHA_FS/m5.debug

scons: Reading SConscript files ...
Checking for C header file fenv.h... yes
Building in /tmp/newmem/build/ALPHA_FS
Options file /tmp/newmem/build/options/ALPHA_FS not found,
  using defaults in build_opts/ALPHA_FS
Compiling in ALPHA_FS with MySQL support.
scons: done reading SConscript files.
scons: Building targets ...
g++ -o build/ALPHA_FS/base/circlebuf.do -c -pipe -fno-strict-aliasing
    -Wall -Wno-sign-compare -Werror -Wundef -g3 -gdwarf-2 -O0
    -DTHE_ISA=ALPHA_ISA -DDEBUG -Iext/dnet -I/usr/include/python2.4
    -Ibuild/libelf/include -I/usr/include/mysql -Ibuild/ALPHA_FS
    build/ALPHA_FS/base/circlebuf.cc
...

If your output looked like the above, then congratulations, you've compiled M5!

Each configuration is built in a separate subdirectory of m5/build. For each configuration, the various flavors of binaries are built in the same directory. The default binary that you built above is ALPHA_FS/m5.debug. You can build other binaries by specifying them on the scons command line. Multiple targets can be included on a single command line. As with make, the "-j" option can be used to enable parallel builds (useful on multiprocessor hosts). For example, the following command will build both the optimized Alpha syscall emulation and debug MIPS syscall emulation targets using up to 4 concurrent processes:

% scons -j 4 build/ALPHA_SE/m5.opt scons build/MIPS_SE/m5.debug

Testing your build

Once you've compiled M5, you can verify that the build worked by running regression tests. Regression tests are also run via scons. The command to run all tests for a particular is constructed as follows:

% scons build/<target>/tests/<binary>

For example, to run the regression tests on ALPHA_FS/m5.opt, type:

% scons build/ALPHA_FS/tests/opt

The regression framework is integrated into the scons build process, so the command above will (re)build ALPHA_FS/m5.opt if necessary before running the tests.

Regression tests are further subdivided into three categories ("quick", "medium", and "long") based on runtime. You can run only the tests in a particular category by adding that category name to the target path, e.g.:

% scons build/ALPHA_FS/tests/opt/quick

(Note that currently the "medium" and "long" categories are empty; all of the tests are "quick".)

Specific tests can be run by appending the test name:

% scons build/ALPHA_FS/tests/opt/quick/10.linux-boot

For more details, see Regression tests.