| title | layout | order | category |
|---|---|---|---|
Setup Guide |
page |
0 |
tut |
- Mac OS X
- Ubuntu
- Arch Linux
- Fedora
- CentOS
- EWS/EngrIT (this is UIUC-specific)
- Windows
- Generic Setup Notes
Mac OS X 10.6 or higher is required. You may have success with 10.5, but this is not tested.
You will need to have homebrew installed, as well as the
Command Line Tools for Xcode (homebrew requires these as well, and it will
prompt for them during install, or you can install them with xcode-select --install on recent versions of OS X).
Once you have homebrew installed, run the following commands to get the dependencies for MeTA:
{% highlight bash %} brew update brew install cmake jemalloc lzlib icu4c {% endhighlight %}
To get started, run the following commands:
{% highlight bash %}
git clone https://github.com/meta-toolkit/meta.git cd meta/
git submodule update --init --recursive
mkdir build cd build cp ../config.toml .
CXX=clang++ cmake ../ -DCMAKE_BUILD_TYPE=Release -DICU_ROOT=/usr/local/opt/icu4c make {% endhighlight %}
You can now test the system by running the following command:
{% highlight bash %} ./unit-test --reporter=spec {% endhighlight %}
If everything passes, congratulations! MeTA seems to be working on your system.
The directions here depend greatly on your installed version of Ubuntu. To check what version you are on, run the following command:
{% highlight bash %} cat /etc/issue {% endhighlight %}
If it reads "Ubuntu 12.04 LTS" or something of that nature, see the Ubuntu 12.04 LTS Build Guide. If it reads "Ubuntu 14.04 LTS" (or 14.10), see the Ubuntu 14.04 LTS Build Guide. If your version is less than 12.04 LTS, your operating system is not supported (even by your vendor) and you should upgrade to at least 12.04 LTS (or 14.04 LTS, if possible).
Building on Ubuntu 12.04 LTS requires more work than its more up-to-date 14.04 sister, but it can be done relatively easily. You will, however, need to install a newer C++ compiler from a ppa, and switch to it in order to build meta. We will also need to install a newer CMake version than is natively available.
Start by running the following commands to get the dependencies that we will need for building MeTA.
{% highlight bash %}
sudo apt-get update sudo apt-get install python-software-properties
sudo add-apt-repository ppa:ubuntu-toolchain-r/test sudo apt-get update
sudo apt-get install g++ g++-4.8 git make wget libjemalloc-dev zlib1g-dev
wget http://www.cmake.org/files/v3.2/cmake-3.2.0-Linux-x86_64.sh sudo sh cmake-3.2.0-Linux-x86_64.sh --prefix=/usr/local {% endhighlight %}
During CMake installation, you should agree to the license and then say "n" to including the subdirectory. You should be able to run the following commands and see the following output:
{% highlight bash %} g++-4.8 --version {% endhighlight %}
should print
g++-4.8 (Ubuntu 4.8.1-2ubuntu1~12.04) 4.8.1
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
and
{% highlight bash %} /usr/local/bin/cmake --version {% endhighlight %}
should print
cmake version 3.2.0
CMake suite maintained and supported by Kitware (kitware.com/cmake).
Once the dependencies are all installed, you should be ready to build. Run the following commands to get started:
{% highlight bash %}
git clone https://github.com/meta-toolkit/meta.git cd meta/
git submodule update --init --recursive
mkdir build cd build cp ../config.toml .
CXX=g++-4.8 /usr/local/bin/cmake ../ -DCMAKE_BUILD_TYPE=Release make {% endhighlight %}
You can now test the system by running the following command:
{% highlight bash %} ./unit-test --reporter=spec {% endhighlight %}
If everything passes, congratulations! MeTA seems to be working on your system.
Ubuntu 14.04 has a recent enough GCC for building MeTA, but we'll need to add a ppa for a more recent version of CMake.
Start by running the following commands to install the dependencies for MeTA.
{% highlight bash %}
sudo apt-get update sudo apt-get install software-properties-common
sudo add-apt-repository ppa:george-edison55/cmake-3.x sudo apt-get update
sudo apt-get install g++ cmake libicu-dev git libjemalloc-dev zlib1g-dev {% endhighlight %}
Once the dependencies are all installed, you should double check your versions by running the following commands.
{% highlight bash %} g++ --version {% endhighlight %}
should output
g++ (Ubuntu 4.8.2-19ubuntu1) 4.8.2
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
and
{% highlight bash %} cmake --version {% endhighlight %}
should output
cmake version 3.2.2
CMake suite maintained and supported by Kitware (kitware.com/cmake).
Once the dependencies are all installed, you should be ready to build. Run the following commands to get started:
{% highlight bash %}
git clone https://github.com/meta-toolkit/meta.git cd meta/
git submodule update --init --recursive
mkdir build cd build cp ../config.toml .
cmake ../ -DCMAKE_BUILD_TYPE=Release make {% endhighlight %}
You can now test the system by running the following command:
{% highlight bash %} ./unit-test --reporter=spec {% endhighlight %}
If everything passes, congratulations! MeTA seems to be working on your system.
Arch Linux consistently has the most up to date packages due to its rolling release setup, so it's often the easiest platform to get set up on.
To install the dependencies, run the following commands.
{% highlight bash %} sudo pacman -Sy sudo pacman -S clang cmake git icu libc++ make jemalloc zlib {% endhighlight %}
Once the dependencies are all installed, you should be ready to build. Run the following commands to get started:
{% highlight bash %}
git clone https://github.com/meta-toolkit/meta.git cd meta/
git submodule update --init --recursive
mkdir build cd build cp ../config.toml .
CXX=clang++ cmake ../ -DCMAKE_BUILD_TYPE=Release make {% endhighlight %}
You can now test the system by running the following command:
{% highlight bash %} ./unit-test --reporter=spec {% endhighlight %}
If everything passes, congratulations! MeTA seems to be working on your system.
This has been tested with Fedora 22+ (the oldest currently supported Fedora
as of the time of writing). You may have success with earlier versions, but
this is not tested. (If you're on an older version of Fedora, use yum
instead of dnf for the commands given below.)
To get started, install some dependencies:
{% highlight bash %}
sudo dnf install make git wget gcc-c++ jemalloc-devel cmake zlib-devel {% endhighlight %}
You should be able to run the following commands and see the following output:
{% highlight bash %} g++ --version {% endhighlight %}
should print
g++ (GCC) 5.3.1 20151207 (Red Hat 5.3.1-2)
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
and
{% highlight bash %} cmake --version {% endhighlight %}
should print
cmake version 3.3.2
CMake suite maintained and supported by Kitware (kitware.com/cmake).
Once the dependencies are all installed, you should be ready to build. Run the following commands to get started:
{% highlight bash %}
git clone https://github.com/meta-toolkit/meta.git cd meta/
git submodule update --init --recursive
mkdir build cd build cp ../config.toml .
cmake ../ -DCMAKE_BUILD_TYPE=Release make {% endhighlight %}
You can now test the system with the following command:
{% highlight bash %} ./unit-test --reporter=spec {% endhighlight %}
MeTA can be built in CentOS 7 and above. CentOS 7 comes with a recent
enough compiler (GCC 4.8.5), but too old a version of CMake. We'll thus
install the compiler and related libraries from the package manager and
install our own more recent cmake ourselves.
{% highlight bash %}
sudo yum install gcc gcc-c++ git make wget zlib-devel epel-release sudo yum install jemalloc-devel
wget http://www.cmake.org/files/v3.2/cmake-3.2.0-Linux-x86_64.sh sudo sh cmake-3.2.0-Linux-x86_64.sh --prefix=/usr/local --exclude-subdir {% endhighlight %}
You should be able to run the following commands and see the following output:
{% highlight bash %} g++ --version {% endhighlight %}
should print
g++ (GCC) 4.8.5 20150623 (Red Hat 4.8.5-4)
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
and
{% highlight bash %} /usr/local/bin/cmake --version {% endhighlight %}
should print
cmake version 3.2.0
CMake suite maintained and supported by Kitware (kitware.com/cmake).
Once the dependencies are all installed, you should be ready to build. Run the following commands to get started:
{% highlight bash %}
git clone https://github.com/meta-toolkit/meta.git cd meta/
git submodule update --init --recursive
mkdir build cd build cp ../config.toml .
/usr/local/bin/cmake ../ -DCMAKE_BUILD_TYPE=Release make {% endhighlight %}
You can now test the system by running the following command:
{% highlight bash %} ./unit-test --reporter=spec {% endhighlight %}
If everything passes, congratulations! MeTA seems to be working on your system.
Note: Please don't do this if you are able to get MeTA working in any
other possible way, as the EWS filesystem has a habit of being
unbearably slow and increasing compile times by several orders of
magnitude. For example, comparing the cmake, make, and unit-test
steps on my desktop vs. EWS gives the following:
{: .bg-danger style="padding: 15px;" }
| system | cmake time |
make time |
unit-test time |
|---|---|---|---|
| my desktop | 0m7.523s | 2m30.715s | 0m36.631s |
| EWS | 1m28s | 11m28.473s | 1m25.326s |
| {: .table} |
If you are on a machine managed by Engineering IT at UIUC, you should follow this guide. These systems have software that is too old for building MeTA, but EngrIT has been kind enough to package updated versions of research software as modules. The modules provided for GCC and CMake are recent enough to build MeTA, so it is actually mostly straightforward.
To set up your dependencies (you will need to do this every time you log back in to the system), run the following command:
{% highlight bash %} module load gcc module load cmake/3.5.0 {% endhighlight %}
Once you have done this, double check your versions by running the following commands.
{% highlight bash %} g++ --version {% endhighlight %}
should output
gcc (GCC) 5.3.0
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
and
{% highlight bash %} cmake --version {% endhighlight %}
should output
cmake version 3.5.0
CMake suite maintained and supported by Kitware (kitware.com/cmake).
If your versions are correct, you should be ready to build. To get started, run the following commands:
{% highlight bash %}
git clone https://github.com/meta-toolkit/meta.git cd meta/
git submodule update --init --recursive
mkdir build cd build cp ../config.toml .
CXX=which g++ CC=which gcc cmake ../ -DCMAKE_BUILD_TYPE=Release
make
{% endhighlight %}
You can now test the system by running the following command:
{% highlight bash %} ./unit-test --reporter=spec {% endhighlight %}
If everything passes, congratulations! MeTA seems to be working on your system.
MeTA can be built on Windows using the MinGW-w64 toolchain with gcc. We strongly recommend using MSYS2 as this makes fetching the compiler and related libraries significantly easier than it would be otherwise, and it tends to have very up-to-date packages relative to other similar MinGW distributions.
Note: If you find yourself confused or lost by the instructions below, please refer to our visual setup guide for Windows which includes screenshots for every step, including updating MSYS2 and the MinGW-w64 toolchain. {: .bg-warning style="padding: 15px;" }
To start, download the installer for MSYS2 from the linked website and follow the instructions on that page. Once you've got it installed, you should use the MinGW shell to start a new terminal, in which you should run the following commands to download dependencies and related software needed for building:
{% highlight bash %} pacman -Syu git make patch mingw-w64-x86_64-{gcc,cmake,icu,jemalloc,zlib} --force {% endhighlight %}
(the --force is needed to work around a bug with the latest MSYS2
installer as of the time of writing.)
Then, exit the shell and launch the "MinGW-w64 Win64" shell. You can obtain the toolkit and get started with:
{% highlight bash %}
git clone https://github.com/meta-toolkit/meta.git cd meta
git submodule update --init --recursive
mkdir build cd build cp ../config.toml .
cmake .. -G "MSYS Makefiles" -DCMAKE_BUILD_TYPE=Release make {% endhighlight %}
You can now test the system by running the following command:
{% highlight bash %} ./unit-test --reporter=spec {% endhighlight %}
If everything passes, congratulations! MeTA seems to be working on your system.
-
There are rules for clean, tidy, and doc. After you run the
cmakecommand once, you will be able to just runmakeas usual when you're developing---it'll detect when the CMakeLists.txt file has changed and rebuild Makefiles if it needs to. -
To compile in debug mode, just replace
ReleasewithDebugin the appropriatecmakecommand for your OS above and rebuild usingmakeafter. -
Don't hesitate to reach out on the forum if you encounter problems getting set up. We routinely build with a wide variety of compilers and operating systems through our continuous integration setups (travis-ci for Linux and OS X and Appveyor for Windows), so we can be fairly certain that things should build on nearly all major platforms.