AMD MIGraphX is AMD's graph inference engine, which accelerates machine learning model inference. To use MIGraphX, you can install the binaries or build from source code. Refer to the following sections for Ubuntu installation instructions (we'll provide instructions for other Linux distributions in the future).
Note
You must install ROCm before installing MIGraphX.
Install binaries using:
sudo apt update && sudo apt install -y migraphx
Header files and libraries are installed under /opt/rocm-<version>
, where <version>
is the ROCm
version.
You have three options for building from source:
-
ROCm build tool: Uses rbuild to install prerequisites, then you can build the libraries with a single command.
-
CMake: Uses a script to install prerequisites, then you can use CMake to build the source.
-
Docker: Builds a Docker image with all prerequisites installed, then you can build the MIGraphX sources inside a Docker container.
The following is a list of prerequisites for building MIGraphX.
- ROCm CMake modules required
- MIOpen for running on the GPU
- rocBLAS for running on the GPU
- HIP for running on the GPU
- Protobuf for reading onnx files
- Half, an IEEE 754-based half-precision floating point library
- pybind11 for python bindings
- JSON for model serialization to json string format
- MessagePack for model serialization to binary format
- SQLite3 to create database of kernels' tuning information or run queries on existing database
Use the ROCm build tool rbuild.
-
Install
rocm-cmake
,pip3
,rocblas
, andmiopen-hip
:sudo apt install -y rocm-cmake python3-pip rocblas miopen-hip
-
Install rbuild (sudo may be required):
pip3 install https://github.com/RadeonOpenCompute/rbuild/archive/master.tar.gz
-
Build MIGraphX source code:
rbuild build -d depend -B build -DGPU_TARGETS=$(/opt/rocm/bin/rocminfo | grep -o -m1 'gfx.*')
Once completed, all prerequisites are in the depend
folder and MIGraphX is in the build
directory.
Note
If you get an rbuild: command not found
error, it's because rbuild
is installed in $HOME/.local/bin
,
which is not in PATH
. You can either export PATH as export PATH=$HOME/.local/bin:$PATH
to add
the folder to PATH
, or add the option --prefix /usr/local
in the pip3 command when installing rbuild
.
-
Install the prerequisites:
rbuild prepare -d depend
This puts all the prerequisites are in
depend
the folder. They can be used in thecmake
configuration as-DCMAKE_PREFIX_PATH=depend
.If you have sudo access, as an alternative to the
rbuild
command, you can install the prerequisites in the same way as a Dockerfile, by calling./tools/install_prereqs.sh
.By default, all prerequisites are installed at the default location (
/usr/local
) and are accessible by all users. For the default location,sudo
is required to run the script. You can also specify a different location using./tools/install_prereqs.sh $custom_location
. -
Go to the project folder and create a
build
directory:mkdir build cd build
-
Configure CMake. If the prerequisites are installed at the default location
/usr/local
, use:CXX=/opt/rocm/llvm/bin/clang++ cmake .. -DGPU_TARGETS=$(/opt/rocm/bin/rocminfo | grep -o -m1 'gfx.*')
Otherwise, you need to set
-DCMAKE_PREFIX_PATH=$your_loc
to configure CMake. -
Build MIGraphX source code:
make -j$(nproc)
You can verify this using:
make -j$(nproc) check
-
Install MIGraphX libraries:
make install
The easiest way to set up the development environment is to use Docker.
-
With the Dockerfile, build a Docker image:
docker build -t migraphx .
-
Enter the development environment using
docker run
:docker run --device='/dev/kfd' --device='/dev/dri' -v=`pwd`:/code/AMDMIGraphX -w /code/AMDMIGraphX --group-add video -it migraphx
-
In the Docker container, all required prerequisites are already installed, so you can go to the folder
/code/AMDMIGraphX
and follow the steps (starting from 2) in the Use CMake to build MIGraphX.
To use MIGraphX's Python module, you can set PYTHONPATH
or use the .deb
package:
-
Setting
PYTHONPATH
:export PYTHONPATH=/opt/rocm/lib:$PYTHONPATH
-
Creating the
deb
package:make package
This provides the path for .deb package.
To install:
dpkg -i <path_to_deb_file>
To use MIGraphX's C/C++ API in your CMake project, you must set CMAKE_PREFIX_PATH
to the
MIGraphX installation location and run:
find_package(migraphx)
target_link_libraries(myApp migraphx::c)
Where myApp
is the CMake target in your project.
Using rbuild
, you can install the dependencies for development with:
rbuild develop -DGPU_TARGETS=$(/opt/rocm/bin/rocminfo | grep -o -m1 'gfx.*')
This installs development dependencies in the deps
directory and configures cmake
to use those
dependencies in the build
directory. You can change these directories by passing the --deps-dir
and
--build-dir
flags to the rbuild
command:
rbuild develop --build-dir build_rocm_55 --deps-dir /home/user/deps_dir
HTML and PDF documentation can be built using:
cmake --build . --config Release --target doc
OR make doc
This will build a local searchable web site inside the docs/html folder.
Documentation is built using Doxygen and rocm-docs-core
Run the steps below to build documentation locally.
cd docs
pip3 install -r sphinx/requirements.txt
python3 -m sphinx -T -E -b html -d _build/doctrees -D language=en . _build/html
Depending on your setup sudo
may be required for the pip install.
All the code is formatted using clang-format. To format a file, use:
clang-format-10 -style=file -i <path-to-source-file>
Also, githooks can be installed to format the code per-commit:
./.githooks/install