ACL2 Version 6.3 Installation Guide: Requirements

# Requirements

[Back to main page of Installation Guide.]

ACL2 Version 6.3
Copyright (C) 2013, Regents of the University of Texas
ACL2 is licensed under the terms of the LICENSE file distributed with ACL2.

### Table of Contents

- Performance comparisons
- Obtaining Common Lisp (alphabetical listing)
  - Obtaining Allegro Common Lisp
  - Obtaining CCL (OpenMCL)
  - Obtaining CLisp
  - Obtaining CMU Common Lisp
  - Obtaining GCL
  - Obtaining LispWorks
  - Obtaining SBCL

### Performance comparisons

You can see recent performance numbers by following this link, or by going to the ACL2 home page and following the link "Recent changes to this page".

### Obtaining Common Lisp

ACL2 works on Unix, GNU-Linux, and Mac OS X, which we call "Unix-like systems", as well as many Windows operating systems (at least including Windows 98, Windows 2000, and Windows XP). It can be built on top of any of the following Common Lisps, listed here alphabetically.

- Allegro Common Lisp

- CCL (OpenMCL)

- CLisp

- CMU Common Lisp

- GCL

- LispWorks

- SBCL

Obtaining Allegro Common Lisp

The website for Allegro Common Lisp, a commercial implementation, is `http://www.franz.com/`. You may be able to obtain a trial version there.

Obtaining CCL (OpenMCL)

Clozure CL (CCL) was formerly known as OpenMCL. Quoting from the Clozure CL web page: ``Clozure CL is a fast, mature, open source Common Lisp implementation that runs on Linux, Mac OS X and BSD on either Intel x86-64 or PPC.''

For Windows users: We observed stalls using CCL 1.5 on Windows (in May, 2010), though not with CCL 1.4. We have been told by a CCL implementor that this bug has been fixed, and people running CCL 1.5 under Windows at a revision less than 13900 should update.

Here is an easy way to obtain and build the latest version (generally recommended) for Linux on running on x86 or x86-64. First execute the following shell command to create a `ccl` directory, but substituting for `linuxx86`, if appropriate, any of `darwinx86` (which we use for modern Macs), `freebsdx86`, `solarisx86`, `windows`, `darwinppc`, or `linuxppc`.

    svn co http://svn.clozure.com/publicsvn/openmcl/trunk/linuxx86/ccl

Note: if you prefer the latest release, you can obtain that instead, for example as follows (but replace "1.9" by the latest version, for example as described at `http://ccl.clozure.com/download.html`, and replace `linuxx86` if appropriate as described above).

    svn co http://svn.clozure.com/publicsvn/openmcl/release/1.9/linuxx86/ccl

Next rebuild the executable by issuing the following commands, but replace "`./lx86cl64`" by a suitable executable; e.g., for 64-bit Darwin (on Mac OS) use "`./dx86cl64`".

    ./lx86cl64
    (rebuild-ccl :full t)
    (quit)
    ./lx86cl64
    (rebuild-ccl :full t)
    (quit)

Now your CCL executable is up to date. Next, create a suitable script, say as follows, where `DIR` is the full pathname for the directory above the new `ccl` directory.

    #!/bin/sh

    tmp=`uname -a | fgrep x86_64`
    export CCL_DEFAULT_DIRECTORY=DIR/ccl
    # Start up 64-bit or 32-bit lisp, respectively:
    if [ "$tmp" != "" ] ; then \
        DIR/ccl/scripts/ccl64 $* ; \
    else \
        DIR/ccl/scripts/ccl $* ; \
    fi

Be sure to make your script executable. For example, if your script filename is `my-script` then on linux you might want to execute the following shell command.

    chmod +x my-script

Your script (invoked with a suitable pathname, or just the filename if the directory is on your path) will now start the updated CCL lisp image.

More details if you want or need them:
Step 3 in `http://trac.clozure.com/openmcl/wiki/UpdatingFromSource` has more details on building from source. Alternatively, you can download a gzipped tar file; see the main CCL page, or visit the page of stable Clozure CL snapshots for ACL2 users. (Subversion and gzipped tar files are great, but not so much a CCL disk image (`.dmg` file), as we have had a report of the extracted CCL opening its own window when you start it up.) If you don't want to write your own script (as suggested above) then after obtaining CCL, you may wish to edit file `ccl/scripts/ccl` or file `ccl/scripts/ccl64`, depending on whether you want to use a 32-bit or 64-bit version (respectively).

Obtaining CLISP

CLISP is a non-commercial Common Lisp implementation, available from `http://clisp.cons.org/`.

Obtaining CMU Common Lisp

CMU Common Lisp (sometimes called CMUCL) is a non-commercial Common Lisp implementation, available from `http://www.cons.org/cmucl/`.

Obtaining GCL

You might be able to download a binary Debian package for ACL2. Thanks to Camm Maguire for maintaining this package. Note however that it may take some time after each ACL2 release for this binary Debian package to be updated for that release. Here is a shell command that might be used to obtain that package (if running Debian).

    apt-get -q install gcl gcl-doc

Otherwise, it should be easy to obtain and build GCL yourself. There are two recommended versions of GCL for building ACL2: GCL 2.6.8 and GCL 2.6.10. (GCL 2.6.9, which is not recommended, has some issues that were fixed in GCL 2.6.10.) GCL 2.6.8 appears to be faster for ACL2 regressions than GCL 2.6.10; we obtained the following times on a 64-bit Linux system using a development snapshot of ACL2 as of Sept. 23, 2013.

       ACL2 built on non-ANSI GCL 2.6.8:
       33235.713u 1275.991s 1:29:23.91 643.4%	0+0k 156624+4638504io 25pf+0w

       ACL2 built on non-ANSI GCL 2.6.10pre:
       40678.982u 1013.967s 1:45:06.91 661.0%	0+0k 153400+6615176io 9pf+0w

       ACL2 built on ANSI GCL 2.6.10pre:
       67950.466u 1050.753s 2:44:58.65 697.0%	0+0k 327160+6955712io 7pf+0w

On the other hand, modern Common Lisp implementations are ANSI compliant, and GCL 2.6.10 may have better ANSI support (which is needed if you choose to build ACL2(h)).

As of this writing (late September 2013), it might be best to fetch GCL 2.6.8 for most purposes but GCL 2.6.10 if for some reason you want an ANSI build of GCL. You can fetch it as a tarball from main GNU website for GCL. From GCL source you can build an executable by extracting from the tarball, standing in the resulting `gcl/` directory, and issuing one of the following commands.

    # Recommended for 64-bit Linux:
    ./configure --enable-maxpage=1048576 && make

    # Recommended for Mac OS:
    ./configure && make

    # If you want an ANSI build
    # (but add "--enable-maxpage=1048576" as above for linux):
    ./configure --enable-ansi && make

As of late September 2013, GCL 2.6.10 is not yet available as a tarball. However, you can get a pre-release (which we expect to work fine, having used it successfully ourselves) like this (assuming you have `git` installed):

    git clone git://git.sv.gnu.org/gcl.git
    cd gcl
    git checkout Version_2_6_10pre
    cd gcl

Then run `configure` and `make` as indicated above.

Obtaining LispWorks

LispWorks is a commercial Common Lisp implementation. You can download a free, restricted, version from `http://www.lispworks.com/`. You may ask the vendor for an evaluation license for the full product if you are considering purchasing a license.

Obtaining SBCL

SBCL (Steel Bank Common Lisp) is a non-commercial Common Lisp implementation, available from `http://sbcl.sourceforge.net/`.

[Back to Installation Guide.]