a bit of patience, please ... while the text is
mostly written, you will notice that the links to actual code don't
work. But I'm working on that, honest!
It is not as easy as you might think. The code and the benchmarks
are free for the asking, but due to all kinds of legal
restrictions, you need to
- download and read the license agreement
- sign it and return it to us by FAX: # (217) 333-3501 c/o
George Almasi
or by snail mail:
MAJIC Project
c/o George Almasi
3315 Digital Computer Lab
1304 West Springfield Avenue
Urbana, IL 61801
- Upon receipt of the signed license agreement we will send you a
username and password by email. Use these to access the actual files:
MAJIC is not 100% compatible with MATLAB. We were primarily interested
in showing how computation can be sped up, and so we stuck to MATLAB 4
kinds of expressions; we do not support cell arrays or object-oriented
features of MATLAB. MAJIC doesn't do any graphics either, although it
can call up MATLAB to do some rudimentary graphics (mainly for
the purpose of checking that the results are correct). There are many
other gotchas, too.
Compiling MAJIC is also not a walk in the park. There are two basic
options: compiling with, or without, JIT support. Without JIT support
you only get the interpreter. There might be several reasons why you
would need an interpreter that can tinker with MATLAB code; Vijay uses this
option to build his vectorizer.
Without JIT support MAJIC can be built on almost any architecture. You
will need:
- MATLAB 5.3
installed. MAJIC uses the MATLAB runtime library. Sorry, it
won't work with 5.2 or earlier - the C/C++ libraries have changed
somewhat;
- A template-compliant C++ compiler, like gcc (MAJIC has
been built with gcc 2.8.1 and 2.95.1) or Sparcworks C++ 4.1;
- The Standard Template Library. If you use gcc, don't worry
about it - gcc contains the STL by default. If you compile on an SGI
workstation using SGI's native C++ compiler, again, STL should be on
the system by default. If you use Sparcworks C++ on a Solaris
workstation - or any of a number of other architectures with native
C++ compilers - you can use Boris Fomitchev's STLport, already included with the
MAJIC release.
- The following packages: M4, awk, sed,
gperf version 2.7 or later, nm and bison. If you
don't have any of these packages, you will find out about it when you
try compiling MAJIC - talk with your system administrator
then. Normally your computer should have these.
- The MAJIC source code
release. Remember to ask me for a username and password to
download it.
When you have all of these, install MAJIC into a directory and type
"configure" and it should auto-configure itself (I hope).
Compiling MAJIC with JIT support
In addition to all of the things listed above, you will a tcc distribution. However, not
all versions will work; I have had to jazz up tcc a little bit to make
it work. Even so, I can only make it work on the Solaris platform. I
don't have access to DEC MIPS machines, and the SGI MIPS version of
tcc fails because of a stupid assembler bug which I haven't had time
to fix yet. x86 ... well, just forget it for now. vcode (the part of
tcc which generates machine code, originally written by Dawson Engler) is not
functional on x86 platforms yet, despite the considerable effort Max
put into it.
- Either get tcc version
1.09b from Max Poletto and apply
my patches to it;
- or get an already patched version of tcc here. Max has gracefully allowed me to
redistribute tcc.
Compile tcc according to instructions found in the package, and make
the compiled tcc executable into your path. Then reconfigure MAJIC -
it will detect the presence of tcc and compile with JIT support.
Some of these benchmarks have been taken from the book "NUMERICAL
METHODS for Mathematics" by John H. Mathews. I have yet to tell him
about this! I hope he won't mind. Other benchmarks are courtesy of
Richard Bramley of Indiana University, and the same applies
there. There are benchmarks whose source I can't find - if you
wrote the benchmark and would like to have it removed from this
website, please email me!
The programs have been mangled to make them compatible with FALCON;
the MAJIC project kept the programs mangled because we want to know
how we fare compared to FALCON. The program descriptions, however,
have not been all changed, which means that you have to take
all commments with a pinch of salt.
As a general rule, for benchmark X the driver routine (the one you
call from the command line) is called drv_X, and the algorithm (which
actually does the processing) is called tst_X. But there are other,
anciliary, files that do not conform to this protocol.
Some routines display a running count of the iterations, some
don't. In many routines you will find the print statements commented
out. This means that MAJIC was already getting speedups to the
point where the print statement was taking up a sizable portion of the
routine's runtime.
Running the benchmarks: all benchmarks can be run separately by typing
the name of their driver into matlab. The benchmark will display its
own runtime. If the environment variable DEBUG is set, some of the
benchmarks will display a graphic of the results. The graphs will
appear on the website for comparison.
If you want to run all benchmarks just call the function
run_bmrk
.
Description of individual benchmarks
ADAPT: adaptive quadrature of a fixed function
drv_adapt.m
tst_adapt.m
CGOPT: preconditioned conjugate gradient method (diagonal preconditioner)
drv_cgopt.m (driver)
tst_mat.mat (contains A and b for solving Ax=b; problem size 420x420)
tst_cgopt.m (algorithm)
CRNICH: Crank-Nicholson method for solving heat equation (parabolic PDE)
drv_crnich.m (driver)
tst_cn.mat (input parameters: problem size m x n = 321 x 321)
tst_crnich.m (algorithm)
trisys.m (subroutine to solve a triangular system of equations)
DIRICH: iterative method for solving laplace's equation
drv_dirich.m (driver)
tst_dirich.mat (input parameters: limits and tolerances)
f_dirich.m (boundary conditions, sort of. Ugly hack)
tst_dirich.m (algorithm)
FINEDIF: simple solution to wave equation (hypebolic PDE)
drv_finedif.m (driver)
tst_pde.mat (input parameters: problem size 451 x 451)
tst_finedif.m (algorithm)
GALRKN: solves Poisson's equation for a two-dimensional dipole
drv_galrkn.m (driver)
tst_galrkn.mat (input parameters: number of points etc)
tst_galrkn.m (algorithm)
ICN: our good friend, the Cholesky factorization
drv_icn.m (driver)
tst_A.mat (matrix to factorize: 400 x 400)
tst_icn.m (algorithm)
MEI: generates a surface, physical meaning unknown.
drv_mei.m (driver)
tst_mei.mat (input parameters: limits and resolution)
tst_mei.m (algorithm)
ORBEC: "one-body problem": plots e.g. the orbit of a comet around the sun.
drv_orbec.m (driver)
INP_orbec.mat (input parameters: initial position, speed, n. of time steps)
tst_orbec.m (algorithm)
ORBRK: same problem as above, but uses a 4th order Runge-Kutta method
drv_orbrk.m (driver)
INP_orbe.mat (input parameters)
tst_orbrk.m (algorithm)
rk4_orb.m (calculates next state ... RK formula)
gravrk.m (simulates the gravity pit)
QMR: quasi-minimal relaxation method, for solving linear equations.
drv_qmr.m (driver)
tst_qmr.m (input data)
tst_qmr.mat (algorithm)
SOR: successive overrelaxation method for solving a linear system of equations
drv_sor.m (driver)
tst_mat.mat (input data)
tst_sor.m (algorithm)