Delete most get_started/ docs and clean up what's left. (#8801)
Most of these pages were rewritten for the new website. I kept the Vulkan, Bazel, Emscripten, and CMake options docs but trimmed them down to only what is not already covered elsewhere.
Part of https://github.com/google/iree/issues/8766
diff --git a/docs/developers/developing_iree/testing_guide.md b/docs/developers/developing_iree/testing_guide.md
index 8537e46..8351092 100644
--- a/docs/developers/developing_iree/testing_guide.md
+++ b/docs/developers/developing_iree/testing_guide.md
@@ -37,7 +37,7 @@
To use the Vulkan backend as test driver, you may need to select between a
Vulkan implementation from SwiftShader and multiple Vulkan-capable hardware
devices. This can be done via environment variables. See the
-[generic Vulkan setup](get_started/generic_vulkan_env_setup.md#useful-environment-variables)
+[generic Vulkan setup](../get_started/vulkan_environment_setup.md#useful-environment-variables)
page for details regarding these variables.
For Bazel, you can persist the configuration in `user.bazelrc` to save typing.
diff --git a/docs/developers/get_started/README.md b/docs/developers/get_started/README.md
new file mode 100644
index 0000000..8bcf918
--- /dev/null
+++ b/docs/developers/get_started/README.md
@@ -0,0 +1,12 @@
+# Additional getting started guides
+
+---
+
+The primary guides are located at
+https://google.github.io/iree/building-from-source/ (source in
+[the website/ folder](../../website/docs/building-from-source/) )
+
+---
+
+The files in this folder contain a mix of legacy and minimal-effort (Bazel)
+documentation.
diff --git a/docs/developers/get_started/getting_started_linux_bazel.md b/docs/developers/get_started/building_with_bazel_linux.md
similarity index 75%
rename from docs/developers/get_started/getting_started_linux_bazel.md
rename to docs/developers/get_started/building_with_bazel_linux.md
index f8f8948..f31feb9 100644
--- a/docs/developers/get_started/getting_started_linux_bazel.md
+++ b/docs/developers/get_started/building_with_bazel_linux.md
@@ -1,15 +1,7 @@
# Getting Started on Linux with Bazel
-<!--
-Notes to those updating this guide:
-
- * This document should be __simple__ and cover essential items only.
- Notes for optional components should go in separate files.
-
- * This document parallels getting_started_windows_bazel.md and
- getting_started_macos_bazel.md
- Please keep them in sync.
--->
+**NOTE** Bazel build support is primarily for internal project infrastructure.
+We strongly recommend users build with CMake instead.
This guide walks through building the core compiler and runtime parts of IREE
from source. Auxiliary components like the Python bindings and Vulkan driver are
@@ -19,9 +11,9 @@
### Install Bazel
-Install Bazel version > 2.0.0 (see
-[`.bazelversion`](https://github.com/google/iree/blob/main/.bazelversion) for
-the specific version IREE uses) by following the
+Install Bazel, matching IREE's
+[`.bazelversion`](https://github.com/google/iree/blob/main/.bazelversion) by
+following the
[official docs](https://docs.bazel.build/versions/master/install.html).
### Install a Compiler
@@ -120,12 +112,3 @@
$ ./bazel-bin/iree/tools/iree-run-mlir ./iree/samples/models/simple_abs.mlir \
-function-input="f32=-2" -iree-hal-target-backends=vmvx -print-mlir
```
-
-### Further Reading
-
-* For an introduction to IREE's project structure and developer tools, see
- [Developer Overview](../developing_iree/developer_overview.md)
-* To target GPUs using Vulkan, see
- [Getting Started on Linux with Vulkan](getting_started_linux_vulkan.md)
-* To use IREE's Python bindings, see
- [Getting Started with Python](getting_started_python.md)
diff --git a/docs/developers/get_started/getting_started_macos_bazel.md b/docs/developers/get_started/building_with_bazel_macos.md
similarity index 78%
rename from docs/developers/get_started/getting_started_macos_bazel.md
rename to docs/developers/get_started/building_with_bazel_macos.md
index 384f31a..bfbff4a 100644
--- a/docs/developers/get_started/getting_started_macos_bazel.md
+++ b/docs/developers/get_started/building_with_bazel_macos.md
@@ -1,15 +1,7 @@
# Getting Started on macOS with Bazel
-<!--
-Notes to those updating this guide:
-
- * This document should be __simple__ and cover essential items only.
- Notes for optional components should go in separate files.
-
- * This document parallels getting_started_linux_bazel.md and
- getting_started_windows_bazel.md
- Please keep them in sync.
--->
+**NOTE** Bazel build support is primarily for internal project infrastructure.
+We strongly recommend users build with CMake instead.
This guide walks through building the core compiler and runtime parts of IREE
from source. Auxiliary components like the Python bindings and Vulkan driver are
@@ -123,13 +115,3 @@
$ ./bazel-bin/iree/tools/iree-run-mlir ./iree/samples/models/simple_abs.mlir \
-function-input="f32=-2" -iree-hal-target-backends=vmvx -print-mlir
```
-
-### Further Reading
-
-* For an introduction to IREE's project structure and developer tools, see
- [Developer Overview](../developing_iree/developer_overview.md).
-* To understand how IREE implements HAL over Metal, see
- [Metal HAL Driver](../design_docs/metal_hal_driver.md). <!-- TODO: Link to
- macOS versions of these guides once they are developed.
-* To use IREE's Python bindings, see
- [Getting Started with Python](getting_started_python.md) -->
diff --git a/docs/developers/get_started/getting_started_windows_bazel.md b/docs/developers/get_started/building_with_bazel_windows.md
similarity index 82%
rename from docs/developers/get_started/getting_started_windows_bazel.md
rename to docs/developers/get_started/building_with_bazel_windows.md
index e08bb2a..9486ae6 100644
--- a/docs/developers/get_started/getting_started_windows_bazel.md
+++ b/docs/developers/get_started/building_with_bazel_windows.md
@@ -1,15 +1,8 @@
# Getting Started on Windows with Bazel
-<!--
-Notes to those updating this guide:
-
- * This document should be __simple__ and cover essential items only.
- Notes for optional components should go in separate files.
-
- * This document parallels getting_started_linux_bazel.md and
- getting_started_macos_bazel.md
- Please keep them in sync.
--->
+**NOTE** Bazel build support is primarily for internal project infrastructure.
+Bazel on Windows in particular is particularly unstable and unsupported.
+We strongly recommend users build with CMake instead.
This guide walks through building the core compiler and runtime parts of IREE
from source. Auxiliary components like the Python bindings and Vulkan driver are
@@ -124,12 +117,3 @@
```powershell
> .\bazel-bin\iree\tools\iree-run-mlir.exe .\iree\samples\models\simple_abs.mlir -function-input="f32=-2" -iree-hal-target-backends=vmvx -print-mlir
```
-
-### Further Reading
-
-* For an introduction to IREE's project structure and developer tools, see
- [Developer Overview](../developing_iree/developer_overview.md)
-* To target GPUs using Vulkan, see
- [Getting Started on Windows with Vulkan](getting_started_windows_vulkan.md)
-* To use IREE's Python bindings, see
- [Getting Started with Python](getting_started_python.md)
diff --git a/docs/developers/get_started/getting_started_emscripten.md b/docs/developers/get_started/building_with_emscripten.md
similarity index 100%
rename from docs/developers/get_started/getting_started_emscripten.md
rename to docs/developers/get_started/building_with_emscripten.md
diff --git a/docs/developers/get_started/getting_started_android_cmake.md b/docs/developers/get_started/getting_started_android_cmake.md
deleted file mode 100644
index 31160ca..0000000
--- a/docs/developers/get_started/getting_started_android_cmake.md
+++ /dev/null
@@ -1,286 +0,0 @@
-# Getting Started on Android with CMake
-
-<!--
-Notes to those updating this guide:
-
- * This document should be __simple__ and cover essential items only.
- Notes for optional components should go in separate files.
--->
-
-This guide walks through cross-compiling IREE core runtime towards the Android
-platform. Cross-compiling IREE compilers towards Android is not supported at the
-moment.
-
-Cross-compilation involves both a *host* platform and a *target* platform. One
-invokes compiler toolchains on the host platform to generate libraries and
-executables that can be run on the target platform.
-
-## Prerequisites
-
-### Set up host development environment
-
-The host platform should have been set up for developing IREE. Right now Linux
-and Windows are supported. Please make sure you have followed the steps for
-[Linux](./getting_started_linux_cmake.md) or
-[Windows](./getting_started_windows_cmake.md).
-
-### Install Android NDK
-
-Android NDK provides compiler toolchains for compiling C/C++ code to target
-Android. You can download it
-[here](https://developer.android.com/ndk/downloads). We recommend to download
-the latest release; the steps in following sections may assume that.
-
-Alternatively, if you have installed
-[Android Studio](https://developer.android.com/studio), you can follow
-[this guide](https://developer.android.com/studio/projects/install-ndk) to
-install Android NDK.
-
-After downloading, it is recommended to set the `ANDROID_NDK` environment
-variable pointing to the directory. For Linux, you can `export` in your shell's
-rc file. For Windows, you can search "environment variable" in the taskbar or
-use `Windows` + `R` to open the "Run" dialog to run
-`rundll32 sysdm.cpl,EditEnvironmentVariables`.
-
-### Install Android Debug Bridge (ADB)
-
-For Linux, search your the distribution's package manager to install `adb`. For
-example, on Ubuntu:
-
-```shell
-$ sudo apt install adb
-```
-
-For Windows, it's easier to get `adb` via Android Studio. `adb` is included in
-the Android SDK Platform-Tools package. You can download this package with the
-[SDK Manager](https://developer.android.com/studio/intro/update#sdk-manager),
-which installs it at `android_sdk/platform-tools/`. Or if you want the
-standalone Android SDK Platform-Tools package, you can
-[download it here](https://developer.android.com/studio/releases/platform-tools).
-You may also want to add the folder to the `PATH` environment variable.
-
-## Configure and build
-
-### Host configuration
-
-Build and install at least the compiler tools on your host machine, or install
-them from a binary distribution:
-
-```shell
-$ cmake -G Ninja -B ../iree-build-host/ -DCMAKE_INSTALL_PREFIX=../iree-build-host/install .
-$ cmake --build ../iree-build-host/ --target install
-```
-
-Debugging note:
- * If you experience the build error similar to issue [#4915](https://github.com/google/iree/issues/4915), update the cmake configuration CLI to
-```shell
-$ cmake -G Ninja -B ../iree-build-host/ \
- -DCMAKE_C_COMPILER=clang \
- -DCMAKE_CXX_COMPILER=clang++ \
- -DCMAKE_INSTALL_PREFIX=../iree-build-host/install .
-```
-
-### Target configuration
-
-Build the runtime using the Android NDK toolchain:
-
-```shell
-$ cmake -G Ninja -B ../iree-build-android/ \
- -DCMAKE_TOOLCHAIN_FILE="${ANDROID_NDK?}/build/cmake/android.toolchain.cmake" \
- -DIREE_HOST_BINARY_ROOT=$(realpath ../iree-build-host/install) \
- -DANDROID_ABI="arm64-v8a" \
- -DANDROID_PLATFORM=android-29 \
- -DIREE_BUILD_COMPILER=OFF \
- -DIREE_BUILD_SAMPLES=OFF \
- .
-$ cmake --build ../iree-build-android/
-```
-
-* The above configures IREE to cross-compile towards 64-bit
- (`-DANDROID_ABI="arm64-v8a"`) Android 10 (`-DANDROID_PLATFORM=android-29`).
- This may require the latest Android NDK release. You can choose the suitable
- [`ANDROID_ABI`](https://developer.android.com/ndk/guides/cmake#android_abi)
- and
- [`ANDROID_PLATFORM`](https://en.wikipedia.org/wiki/Android_version_history)
- for your target device. You can also refer to Android NDK's
- [CMake documentation](https://developer.android.com/ndk/guides/cmake) for
- more toolchain arguments.
-
-## Test on Android
-
-Make sure you
-[enable developer options and USB debugging](https://developer.android.com/studio/debug/dev-options#enable)
-for your Android device.
-
-Connect your Android device to the development machine and make sure you can see
-the device when:
-
-```shell
-$ adb devices
-
-List of devices attached
-XXXXXXXXXXX device
-```
-
-Then you can run all device tests via
-
-```shell
-$ cd ../iree-build-android
-$ ctest --output-on-failure
-```
-
-The above command will upload necessary build artifacts to the Android device's
-`/data/local/tmp` directory, run the tests there, and report status back.
-
-Alternatively, if you want to invoke a specific HAL backend on a IREE module:
-
-### VMLA HAL backend
-
-Translate a source MLIR into IREE module:
-
-```shell
-# Assuming in IREE source root
-$ ../iree-build-host/install/bin/iree-compile \
- -iree-hal-target-backends=vmvx \
- $PWD/iree/samples/models/simple_abs.mlir \
- -o /tmp/simple_abs_vmvx.vmfb
-```
-
-Then push the IREE runtime executable and module to the device:
-
-```shell
-$ adb push ../iree-build-android/iree/tools/iree-run-module /data/local/tmp/
-$ adb shell chmod +x /data/local/tmp/iree-run-module
-$ adb push /tmp/simple_abs_vmvx.vmfb /data/local/tmp/
-```
-
-Log into Android:
-
-```shell
-$ adb shell
-
-android $ cd /data/local/tmp/
-android $ ./iree-run-module \
- --driver=vmvx \
- --module_file=simple_abs_vmvx.vmfb \
- --entry_function=abs \
- --function_input=f32=-5
-
-EXEC @abs
-f32=5
-```
-
-### Vulkan HAL backend
-
-Please make sure your Android device is Vulkan capable. Vulkan is supported on
-Android since 7, but Android 10 is our primary target at the moment.
-
-Translate a source MLIR into IREE module:
-
-```shell
-$ ../iree-build-host/install/bin/iree-compile \
- -iree-hal-target-backends=vulkan-spirv \
- $PWD/iree/samples/models/simple_abs.mlir \
- -o /tmp/simple_abs_vulkan.vmfb
-```
-
-Then push the IREE runtime executable and module to the device:
-
-```shell
-$ adb push ../iree-build-android/iree/tools/iree-run-module /data/local/tmp/
-$ adb shell chmod +x /data/local/tmp/iree-run-module
-$ adb push /tmp/simple_abs_vulkan.vmfb /data/local/tmp/
-```
-
-Log into Android:
-
-```shell
-$ adb shell
-
-android $ cd /data/local/tmp/
-android $ ./iree-run-module \
- --driver=vulkan \
- --module_file=simple_abs_vulkan.vmfb \
- --entry_function=abs \
- --function_input=f32=-5
-
-EXEC @abs
-f32=5
-```
-
-#### Common issues
-
-##### Vulkan function `vkCreateInstance` not available
-
-Since Android 8 Oreo, Android re-architected the OS framework with
-[project Treble](https://source.android.com/devices/architecture#hidl).
-Framework libraries and
-[vendor libraries](https://source.android.com/devices/architecture/vndk) have a
-more strict and clear separation. Their dependencies are carefully scrutinized
-and only selected cases are allowed. This is enforced with
-[linker namespaces](https://source.android.com/devices/architecture/vndk/linker-namespace).
-
-`/data/local/tmp` is the preferred directory for automating native binary tests
-built using NDK toolchain. They should be allowed to access libraries like
-`libvulkan.so` for their functionality. However, there was an issue with fully
-treblized Android 10 where `/data/local/tmp` did not have access to the linker
-namespaces needed by `libvulkan.so`. This should be
-[fixed](https://android.googlesource.com/platform/system/linkerconfig/+/296da5b1eb88a3527ee76352c2d987f82f3252eb)
-now. But as typically in the Android system, it takes a long time to see the fix
-getting propagated, if ever.
-
-A known workaround is to symlink the vendor Vulkan implementation under
-`/vendor/lib[64]` as `libvulkan.so` under `/data/local/tmp` and use
-`LD_LIBRARY_PATH=/data/local/tmp` when invoking IREE executables.
-
-For Qualcomm Adreno GPUs, the vendor Vulkan implementation is at
-`/vendor/lib[64]/hw/vulkan.*.so`. So for example for Snapdragon 865:
-
-```shell
-$ adb shell ln -s /vendor/lib64/hw/vulkan.kona.so /data/local/tmp/libvulkan.so
-```
-
-For ARM Mali GPUs, there is only one monolithic driver
-(`/vendor/lib[64]/libGLES_mali.so`) for OpenGL and Vulkan and the Vulkan vendor
-driver (`/vendor/lib[64]/hw/vulkan.*.so`) is just a symlink to it. So for
-example:
-
-```shell
-$ adb shell ln -s /vendor/lib64/libGLES_mali.so /data/local/tmp/libvulkan.so
-```
-
-### Dylib LLVM AOT backend
-
-Translate a source MLIR into an IREE module:
-
-```shell
-$ ../iree-build-host/install/bin/iree-compile \
- -iree-hal-target-backends=dylib-llvm-aot \
- -iree-llvm-target-triple=aarch64-linux-android \
- $PWD/iree/samples/models/simple_abs.mlir \
- -o /tmp/simple_abs_dylib.vmfb
-```
-
-Then push the IREE runtime executable and module to the device:
-
-```shell
-$ adb push ../iree-build-android/iree/tools/iree-run-module /data/local/tmp/
-$ adb shell chmod +x /data/local/tmp/iree-run-module
-$ adb push /tmp/simple_abs_dylib.vmfb /data/local/tmp/
-```
-
-Log into Android:
-
-```shell
-$ adb shell
-
-android $ cd /data/local/tmp/
-android $ ./iree-run-module \
- --driver=dylib \
- --module_file=simple_abs_dylib.vmfb \
- --entry_function=abs \
- --function_input=f32=-5
-
-EXEC @abs
-f32=5
-```
diff --git a/docs/developers/get_started/getting_started_linux_cmake.md b/docs/developers/get_started/getting_started_linux_cmake.md
deleted file mode 100644
index ce1be20..0000000
--- a/docs/developers/get_started/getting_started_linux_cmake.md
+++ /dev/null
@@ -1,145 +0,0 @@
-# Getting Started on Linux with CMake
-
-<!--
-Notes to those updating this guide:
-
- * This document should be __simple__ and cover essential items only.
- Notes for optional components should go in separate files.
-
- * This document parallels getting_started_windows_cmake.md and
- getting_started_macos_bazel.md
- Please keep them in sync.
--->
-
-This guide walks through building the core compiler and runtime parts of IREE
-from source. Auxiliary components like the Python bindings and Vulkan driver are
-documented separately, as they require further setup.
-
-## Prerequisites
-
-### Install CMake
-
-IREE uses CMake version `>= 3.13.4`. First try installing via your
-distribution's package manager and verify the version:
-
-```shell
-$ sudo apt install cmake
-$ cmake --version # >= 3.13.4
-```
-
-Some package managers (like `apt`) distribute old versions of cmake. If your
-package manager installs a version `< 3.13.4`, then follow the installation
-instructions [here](https://cmake.org/install/) to install a newer version (e.g.
-the latest).
-
-> Tip:<br>
-> Your editor of choice likely has plugins for CMake,
-> such as the Visual Studio Code
-> [CMake Tools](https://github.com/microsoft/vscode-cmake-tools) extension.
-
-### Install Ninja
-
-[Ninja](https://ninja-build.org/) is a fast build system that you can use as a
-CMake generator. Follow Ninja's
-[installing documentation](https://github.com/ninja-build/ninja/wiki/Pre-built-Ninja-packages).
-
-### Install a Compiler
-
-We recommend Clang. GCC is not fully supported.
-
-```shell
-$ sudo apt install clang
-```
-
-## Clone and Build
-
-### Clone
-
-Clone the repository and initialize its submodules:
-
-```shell
-$ git clone https://github.com/google/iree.git
-$ cd iree
-$ git submodule update --init
-```
-
-> Tip:<br>
-> Editors and other programs can also clone the
-> repository, just make sure that they initialize the submodules.
-
-### Build
-
-Configure:
-
-```shell
-$ cmake -G Ninja -B ../iree-build/ -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ .
-```
-
-> Tip:<br>
-> The root
-> [CMakeLists.txt](https://github.com/google/iree/blob/main/CMakeLists.txt)
-> file has options for configuring which parts of the project to enable.<br>
-> These are further documented in [CMake Options and Variables](cmake_options_and_variables.md).
-
-Build all targets:
-
-```shell
-$ cmake --build ../iree-build/
-```
-
-## What's next?
-
-### Take a Look Around
-
-Check out the contents of the 'tools' build directory:
-
-```shell
-$ ls ../iree-build/iree/tools
-$ ../iree-build/iree/tools/iree-compile --help
-```
-
-Translate a
-[MLIR file](https://github.com/google/iree/blob/main/iree/samples/models/simple_abs.mlir)
-and execute a function in the compiled module:
-
-```shell
-$ ../iree-build/iree/tools/iree-run-mlir $PWD/iree/samples/models/simple_abs.mlir \
- -function-input="f32=-2" -iree-hal-target-backends=vmvx -print-mlir
-```
-
-### LLVM Ahead-of-Time (AOT) backend
-
-Translate a source MLIR into an IREE module:
-
-```shell
-# Assuming in IREE source root
-$ ../iree-build/iree/tools/iree-compile \
- -iree-mlir-to-vm-bytecode-module \
- -iree-llvm-target-triple=x86_64-linux-gnu \
- -iree-hal-target-backends=dylib-llvm-aot \
- iree/samples/models/simple_abs.mlir \
- -o /tmp/simple_abs_dylib.vmfb
-```
-
-Then run the compiled module using the `dylib` HAL driver:
-
-```shell
-$ ../iree-build/iree/tools/iree-run-module \
- --driver=dylib \
- --module_file=/tmp/simple_abs_dylib.vmfb \
- --entry_function=abs \
- --function_input=f32=-5
-
-EXEC @abs
-f32=5
-```
-
-
-### Further Reading
-
-* For an introduction to IREE's project structure and developer tools, see
- [Developer Overview](../developing_iree/developer_overview.md)
-* To target GPUs using Vulkan, see
- [Getting Started on Linux with Vulkan](getting_started_linux_vulkan.md)
-* To use IREE's Python bindings, see
- [Getting Started with Python](getting_started_python.md)
diff --git a/docs/developers/get_started/getting_started_linux_vulkan.md b/docs/developers/get_started/getting_started_linux_vulkan.md
deleted file mode 100644
index 05e5493..0000000
--- a/docs/developers/get_started/getting_started_linux_vulkan.md
+++ /dev/null
@@ -1,159 +0,0 @@
-# Getting Started on Linux with Vulkan
-
-[Vulkan](https://www.khronos.org/vulkan/) is a new generation graphics and
-compute API that provides high-efficiency, cross-platform access to modern GPUs
-used in a wide variety of devices from PCs and consoles to mobile phones and
-embedded platforms.
-
-IREE includes a Vulkan/[SPIR-V](https://www.khronos.org/registry/spir-v/) HAL
-backend designed for executing advanced ML models in a deeply pipelined and
-tightly integrated fashion on accelerators like GPUs.
-
-This guide will walk you through using IREE's compiler and runtime Vulkan
-components. For generic Vulkan development environment set up and trouble
-shooting, please see [this doc](generic_vulkan_env_setup.md).
-
-## Prerequisites
-
-You should already have IREE cloned and building on your Linux machine. See the
-[Getting Started on Linux with CMake](getting_started_linux_cmake.md) or
-[Getting Started on Linux with Bazel](getting_started_linux_bazel.md) guide for
-instructions.
-
-You may have a physical GPU with drivers supporting Vulkan. We also support
-using [SwiftShader](https://swiftshader.googlesource.com/SwiftShader/) (a high
-performance CPU-based implementation of Vulkan).
-
-Vulkan drivers implementing API version >= 1.2 are recommended. IREE requires
-the `VK_KHR_timeline_semaphore` extension (part of Vulkan 1.2), though it is
-able to emulate it, with performance costs, as necessary.
-
-## Vulkan Setup
-
-### Background
-
-Please see
-[Generic Vulkan Development Environment Setup and Troubleshooting](generic_vulkan_env_setup.md)
-for generic Vulkan concepts and development environment setup.
-
-### Quick Start
-
-The
-[dynamic_symbols_test](https://github.com/google/iree/blob/main/iree/hal/vulkan/dynamic_symbols_test.cc)
-checks if the Vulkan loader and a valid ICD are accessible.
-
-Run the test:
-
-```shell
-# -- CMake --
-$ export VK_LOADER_DEBUG=all
-$ cmake --build ../iree-build/ --target iree_hal_vulkan_dynamic_symbols_test
-$ ../iree-build/iree/hal/vulkan/iree_hal_vulkan_dynamic_symbols_test
-
-# -- Bazel --
-$ bazel test iree/hal/vulkan:dynamic_symbols_test --test_env=VK_LOADER_DEBUG=all
-```
-
-Tests in IREE's HAL "Conformance Test Suite" (CTS) actually exercise the Vulkan
-HAL, which includes checking for supported layers and extensions.
-
-Run the
-[driver test](https://github.com/google/iree/blob/main/iree/hal/cts/driver_test.h):
-
-```shell
-# -- CMake --
-$ export VK_LOADER_DEBUG=all
-$ cmake --build ../iree-build/ --target iree_hal_vulkan_cts_vulkan_driver_test
-$ cd ../iree-build/
-$ ctest -R iree/hal/vulkan/cts/vulkan_driver_test
-```
-
-If these tests pass, you can skip down to the next section.
-
-### Setting up SwiftShader
-
-If your system lacks a physical GPU with compatible Vulkan drivers, or you just
-want to use a software driver for predictable performance, you can set up
-SwiftShader's Vulkan ICD (Installable Client Driver).
-
-IREE has a
-[helper script](https://github.com/google/iree/blob/main/build_tools/third_party/swiftshader/build_vk_swiftshader.sh)
-for building SwiftShader from source using CMake:
-
-```shell
-$ bash build_tools/third_party/swiftshader/build_vk_swiftshader.sh
-```
-
-<!-- TODO(scotttodd): Steps to download prebuilt binaries when they exist -->
-
-After building, the script will prompt your to add a variable `VK_ICD_FILENAMES`
-to your environment to tell the Vulkan loader to use the ICD. Assuming it was
-installed in the default location, this can be done via:
-
-```shell
-$ export VK_ICD_FILENAMES="${HOME?}/.swiftshader/Linux/vk_swiftshader_icd.json"
-```
-
-### Support in Bazel Tests
-
-Bazel tests run in a sandbox, which environment variables may be forwarded to
-using the `--test_env` flag. A user.bazelrc file supporting each of the steps
-above looks like this (substitute for the `{}` paths):
-
-```
-test --test_env="LD_LIBRARY_PATH={PATH_TO_VULKAN_SDK}/x86_64/lib/"
-test --test_env="LD_PRELOAD=libvulkan.so.1"
-test --test_env="VK_ICD_FILENAMES={PATH_TO_IREE}/build-swiftshader/Linux/vk_swiftshader_icd.json"
-```
-
-## Using IREE's Vulkan Compiler Target and Runtime Driver
-
-### Compiling for the Vulkan HAL
-
-Pass the flag `-iree-hal-target-backends=vulkan-spirv` to `iree-compile`:
-
-```shell
-# -- CMake --
-$ cmake --build ../iree-build/ --target iree_tools_iree-compile
-$ ../iree-build/iree/tools/iree-compile -iree-mlir-to-vm-bytecode-module -iree-hal-target-backends=vulkan-spirv ./iree/samples/models/simple_abs.mlir -o /tmp/module.vmfb
-
-# -- Bazel --
-$ bazel run iree/tools:iree-compile -- -iree-mlir-to-vm-bytecode-module -iree-hal-target-backends=vulkan-spirv $PWD/iree/samples/models/simple_abs.mlir -o /tmp/module.vmfb
-```
-
-> Tip:<br>
-> If successful, this may have no output. You can pass
-> other flags like `-print-ir-after-all` to control the program.
-
-### Executing modules with the Vulkan driver
-
-Pass the flag `-driver=vulkan` to `iree-run-module`:
-
-```shell
-# -- CMake --
-$ cmake --build ../iree-build/ --target iree_tools_iree-run-module
-$ ../iree-build/iree/tools/iree-run-module \
- --driver=vulkan \
- --module_file=/tmp/module.vmfb \
- --entry_function=abs \
- --function_input=f32=-2
-
-# -- Bazel --
-$ bazel run iree/tools:iree-run-module -- \
- --driver=vulkan \
- --module_file=/tmp/module.vmfb \
- --entry_function=abs \
- --function_input=f32=-2
-```
-
-## Running IREE's Vulkan Samples
-
-> Note:<br>
-> The Vulkan samples are CMake-only.
-
-Install the [Vulkan SDK](https://www.lunarg.com/vulkan-sdk/), then run:
-
-```shell
-$ cmake --build ../iree-build/ --target iree_samples_vulkan_vulkan_inference_gui
-$ ../iree-build/iree/samples/vulkan/vulkan_inference_gui
-```
diff --git a/docs/developers/get_started/getting_started_macos_cmake.md b/docs/developers/get_started/getting_started_macos_cmake.md
deleted file mode 100644
index ef5898d..0000000
--- a/docs/developers/get_started/getting_started_macos_cmake.md
+++ /dev/null
@@ -1,118 +0,0 @@
-# Getting Started on macOS with CMake
-
-<!--
-Notes to those updating this guide:
-
- * This document should be __simple__ and cover essential items only.
- Notes for optional components should go in separate files.
-
- * This document parallels getting_started_linux_cmake.md and
- getting_started_windows_cmake.md
- Please keep them in sync.
--->
-
-This guide walks through building the core compiler and runtime parts of IREE
-from source. Auxiliary components like the Python bindings and Vulkan driver are
-not documented for macOS at this time.
-
-IREE is not officially supported on macOS at this time. It may work, but it is
-not a part of our open source CI, and may be intermittently broken.
-Contributions related to macOS support and documentation are welcome however.
-
-## Prerequisites
-
-### Install Homebrew
-
-This guide uses [Homebrew](https://brew.sh/) to install IREE's dependencies.
-
-```shell
-$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
-```
-
-### Install CMake
-
-IREE uses [CMake](https://cmake.org/) version `>= 3.13.4`. Brew ships the latest
-release.
-
-```shell
-$ brew install cmake
-$ cmake --version # >= 3.13.4
-```
-
-### Install Ninja
-
-[Ninja](https://ninja-build.org/) is a fast build system that you can use as a
-CMake generator.
-
-```shell
-$ brew install ninja
-```
-
-## Clone and Build
-
-### Clone
-
-Clone the repository and initialize its submodules:
-
-```shell
-$ git clone https://github.com/google/iree.git
-$ cd iree
-$ git submodule update --init
-```
-
-> Tip:<br>
-> Editors and other programs can also clone the
-> repository, just make sure that they initialize the submodules.
-
-### Build
-
-Configure:
-
-```shell
-$ cmake -G Ninja -B ../iree-build/ .
-```
-
-Note: this should use `Clang` by default on macOS. `GCC` is not fully supported
-by IREE.
-
-> Tip:<br>
-> The root
-> [CMakeLists.txt](https://github.com/google/iree/blob/main/CMakeLists.txt)
-> file has options for configuring which parts of the project to enable.<br>
-> These are further documented in [CMake Options and Variables](cmake_options_and_variables.md).
-
-Build all targets:
-
-```shell
-$ cmake --build ../iree-build/
-```
-
-## What's next?
-
-### Take a Look Around
-
-Check out the contents of the 'tools' build directory:
-
-```shell
-$ ls ../iree-build/iree/tools
-$ ../iree-build/iree/tools/iree-compile --help
-```
-
-Translate a
-[MLIR file](https://github.com/google/iree/blob/main/iree/samples/models/simple_abs.mlir)
-and execute a function in the compiled module:
-
-```shell
-$ ../iree-build/iree/tools/iree-run-mlir $PWD/iree/samples/models/simple_abs.mlir \
- -function-input="f32=-2" -iree-hal-target-backends=vmvx -print-mlir
-```
-
-### Further Reading
-
-* For an introduction to IREE's project structure and developer tools, see
- [Developer Overview](../developing_iree/developer_overview.md).
-* To understand how IREE implements a HAL driver using Metal, see
- [Metal HAL Driver](../design_docs/metal_hal_driver.md). <!-- TODO: Link to
- macOS versions of these guides once they are developed.
-* To use IREE's Python bindings, see
- [Getting Started with Python](getting_started_python.md) -->
diff --git a/docs/developers/get_started/getting_started_python.md b/docs/developers/get_started/getting_started_python.md
deleted file mode 100644
index a10eac8..0000000
--- a/docs/developers/get_started/getting_started_python.md
+++ /dev/null
@@ -1,134 +0,0 @@
-# Getting Started with Python
-
- NOTE: Iree's Python API is currently being reworked. Some of these
- instructions may be in a state of flux as they document the end state.
-
-The IREE compiler API is called `iree.compiler`.
-
-There are additional ancillary modules that are not part of the public API.
-
-Note this guide does not cover IREE integrations with other frontends, such as
-TensorFlow. For those, see the relevant
-[getting started guides](../get-started).
-
-## Prerequisites
-
-You should already have IREE cloned and building on your machine. See the other
-[getting started guides](../get-started) for instructions.
-
-> Note:<br>
-> Support is only complete with CMake.
-
-Minimally, the following CMake flags must be specified:
-
-* `-DIREE_BUILD_PYTHON_BINDINGS=ON`
-
-## Python Setup
-
-Install [Python 3](https://www.python.org/downloads/) `>= 3.7` and
-[pip](https://pip.pypa.io/en/stable/installing/), if needed.
-
-> Note:<br>
-> If using `pyenv` (or an interpreter manager that
- depends on it like `asdf`), you'll need to use
- [`--enable-shared`](https://github.com/pyenv/pyenv/tree/master/plugins/python-build#building-with---enable-shared)
- during interpreter installation.
-
-(Recommended) Setup a virtual environment with `venv` (or your preferred
-mechanism):
-
-```shell
-# Note that venv is only available in python3 and is therefore a good check
-# that you are in fact running a python3 binary.
-$ python -m venv .venv
-$ source .venv/bin/activate
-# When done: run 'deactivate'
-```
-
-As we distribute `manylinux2014` binaries, your pip version should be listed as
-supported on the compatibility table at https://github.com/pypa/manylinux. As
-needed, you can upgrade pip using:
-
-```shell
-$ python -m pip install --upgrade pip
-```
-
-Install packages:
-
-```shell
-$ python -m pip install numpy absl-py
-```
-
-## Building
-
-Configure:
-
-```shell
-cmake -B ../iree-build/ -G Ninja \
- -DCMAKE_C_COMPILER=clang \
- -DCMAKE_CXX_COMPILER=clang++ \
- -DIREE_BUILD_PYTHON_BINDINGS=ON .
-```
-
-Build all targets:
-
-```shell
-$ cmake --build ../iree-build/
-```
-
-## Running Python Tests
-
-Move into the build directory where we made the build in the previous section.
-
-```shell
-$ cd ../iree-build/
-```
-
-To run tests for core Python bindings built with CMake:
-
-```shell
-$ ctest -L bindings/python
-```
-
-## Using Colab
-
-There are some sample colabs in the `colab` folder. If you have built the
-project with CMake/ninja and set your `PYTHONPATH` to the `bindings/python`
-directory in the build dir (or installed per below), you should be able to
-start a kernel by following the stock instructions at
-https://colab.research.google.com/ .
-
-## Installing and Packaging
-
-There is a `setup.py` in the `bindings/python` directory under the build dir.
-To install into your (hopefully isolated) virtual env:
-
-```shell
-# See the above note about python3, and the above step setting PYTHONPATH.
-python bindings/python/setup.py install
-```
-
-To create wheels (platform dependent and locked to your Python version
-without further config):
-
-```shell
-python bindings/python/setup.py bdist_wheel
-```
-
-Note that it is often helpful to differentiate between the environment used to
-build and the one used to install. While this is just "normal" python
-knowledge, here is an incantation to do so:
-
-```shell
-# From parent/build environment.
-python -m pip freeze > /tmp/requirements.txt
-deactivate # If already in an environment
-
-# Enter new scratch environment.
-python -m venv ./.venv-scratch
-source ./.venv-scratch/bin/activate
-python -m pip install -r /tmp/requirements.txt
-
-# Install IREE into the new environment.
-python bindings/python/setup.py install
-```
diff --git a/docs/developers/get_started/getting_started_riscv_cmake.md b/docs/developers/get_started/getting_started_riscv_cmake.md
deleted file mode 100644
index 17791ad..0000000
--- a/docs/developers/get_started/getting_started_riscv_cmake.md
+++ /dev/null
@@ -1,216 +0,0 @@
-# Getting Started on RISC-V with CMake
-
-<!--
-Notes to those updating this guide:
-
- * This document should be __simple__ and cover essential items only.
- Notes for optional components should go in separate files.
--->
-
-This guide walks through cross-compiling IREE core runtime towards the RISC-V
-Linux platform. Cross-compiling IREE compilers towards RISC-V is not supported
-at the moment.
-
-Cross-compilation involves both a *host* platform and a *target* platform. One
-invokes compiler toolchains on the host platform to generate libraries and
-executables that can be run on the target platform.
-
-## Prerequisites
-
-You'll need a RISC-V LLVM compilation toolchain and a RISC-V enabled QEMU
-emulator.
-
-* RISC-V toolchain is built from <https://github.com/llvm/llvm-project> (main branch).
- * Currently, the LLVM compiler is built on GNU toolchain, including libgcc,
- GNU linker, and C libraries. You need to build GNU toolchain first.
- * Clone GNU toolchain from: <https://github.com/riscv/riscv-gnu-toolchain>
- (master branch). Switch the "riscv-binutils" submodule to
- `git://sourceware.org/git/binutils-gdb.git` (master branch) manually.
-* RISC-V QEMU is built from <https://github.com/sifive/qemu/tree/v5.2.0-rvv-rvb-zfh>.
-
-An environment variable `RISCV_TOOLCHAIN_ROOT` needs
-to be set to the root directory of the installed GNU toolchain. The variable can
-be used in building the RISCV target and a LLVM AOT module.
-
-### Install Prebuilt RISC-V Tools (RISC-V 64-bit Linux toolchain)
-
-Execute the following script to download the prebuilt RISC-V toolchain and QEMU:
-
-```shell
-# In IREE source root
-$ ./build_tools/riscv/riscv_bootstrap.sh
-```
-**NOTE**:
-* You also need to set `RISCV_TOOLCHAIN_ROOT`
-(default at ${HOME}/riscv/toolchain/clang/linux/RISCV).
-
-## Configure and build
-
-### Host configuration
-
-Build and install at least the compiler tools on your host machine, or install
-them from a binary distribution:
-
-```shell
-$ cmake -G Ninja -B ../iree-build-host/ \
- -DCMAKE_C_COMPILER=clang \
- -DCMAKE_CXX_COMPILER=clang++ \
- -DCMAKE_INSTALL_PREFIX=../iree-build-host/install \
- .
-$ cmake --build ../iree-build-host/ --target install
-```
-
-### Target configuration
-
-The following instruction shows how to build for the RISC-V 64-bit Linux machine
-and 32-bit bare-metal machine. For other RISC-V targets, please refer to
-[riscv.toolchain.cmake](https://github.com/google/iree/blob/main/build_tools/cmake/riscv.toolchain.cmake)
-as a reference of how to set up the cmake configuration.
-
-#### RISC-V 64-bit Linux target
-```shell
-$ cmake -G Ninja -B ../iree-build-riscv/ \
- -DCMAKE_TOOLCHAIN_FILE="./build_tools/cmake/riscv.toolchain.cmake" \
- -DIREE_HOST_BINARY_ROOT=$(realpath ../iree-build-host/install) \
- -DRISCV_CPU=rv64 \
- -DIREE_BUILD_COMPILER=OFF \
- -DIREE_BUILD_SAMPLES=ON \
- -DRISCV_TOOLCHAIN_ROOT=${RISCV_TOOLCHAIN_ROOT} \
- .
-```
-#### RISC-V 32-bit bare-metal target
-
-For the RISC-V 32-bit bare-metal config, append the following CMake options
-```shell
--DRISCV_CPU=rv32-baremetal \
--DIREE_BUILD_TESTS=OFF
-```
-
-#### Build target
-
-```shell
-$ cmake --build ../iree-build-riscv/
-```
-
-## Test on RISC-V QEMU
-
-**NOTE**:The following instructions are meant for the RISC-V 64-bit Linux
-target. For the bare-metal target, please refer to
-[simple_embedding](https://github.com/google/iree/blob/main/iree/samples/simple_embedding)
-to see how to build a ML workload for a bare-metal machine.
-
-Set the environment variable `RISCV_TOOLCHAIN_ROOT` if it is not set yet:
-
-```shell
-$ export RISCV_TOOLCHAIN_ROOT=<root directory of the RISC-V GNU toolchain>
-```
-
-### VMVX HAL backend
-
-Translate a source MLIR into IREE module:
-
-```shell
-$ ../iree-build-host/install/bin/iree-compile \
- -iree-mlir-to-vm-bytecode-module \
- -iree-hal-target-backends=vmvx \
- ${PWD}/iree/samples/models/simple_abs.mlir \
- -o /tmp/simple_abs_vmvx.vmfb
-```
-
-Then run on the RISC-V QEMU:
-
-Set the path to qemu-riscv64 emulator binary in the `QEMU_BIN` environment
-variable. If it is installed with `riscv_bootstrap.sh`, the path is default at
-${HOME}/riscv/qemu/linux/RISCV/bin/qemu-riscv64.
-
-```shell
-$ export QEMU_BIN=<path to qemu-riscv64 binary>
-```
-
-```shell
-$ ${QEMU_BIN} \
- -cpu rv64,x-v=true,x-k=true,vlen=256,elen=64,vext_spec=v1.0 \
- -L ${RISCV_TOOLCHAIN_ROOT}/sysroot/ \
- ../iree-build-riscv/iree/tools/iree-run-module \
- --driver=vmvx \
- --module_file=/tmp/simple_abs_vmvx.vmfb \
- --entry_function=abs \
- --function_input=f32=-5
-```
-
-Output:
-
-```
-I ../iree/tools/utils/vm_util.cc:227] Creating driver and device for 'vmvx'...
-EXEC @abs
-f32=5
-```
-
-### Dylib LLVM AOT backend
-To compile an IREE module using the Dylib LLVM ahead-of-time (AOT) backend for
-a RISC-V target we need to use the corresponding cross-compile toolchain.
-
-Translate a source MLIR into an IREE module:
-
-```shell
-$ ../iree-build-host/install/bin/iree-compile \
- -iree-mlir-to-vm-bytecode-module \
- -iree-hal-target-backends=dylib-llvm-aot \
- -iree-llvm-target-triple=riscv64 \
- -iree-llvm-target-cpu=sifive-u74 \
- -iree-llvm-target-abi=lp64d \
- ${PWD}/iree/samples/models/simple_abs.mlir \
- -o /tmp/simple_abs_dylib.vmfb
-```
-
-Then run on the RISC-V QEMU:
-
-```shell
-$ ${QEMU_BIN} \
- -cpu rv64,x-v=true,x-k=true,vlen=256,elen=64,vext_spec=v1.0 \
- -L ${RISCV_TOOLCHAIN_ROOT}/sysroot/ \
- ../iree-build-riscv/iree/tools/iree-run-module \
- --driver=dylib \
- --module_file=/tmp/simple_abs_dylib.vmfb \
- --entry_function=abs \
- --function_input=f32=-5
-```
-
-Output:
-
-```
-I ../iree/tools/utils/vm_util.cc:227] Creating driver and device for 'dylib'...
-EXEC @abs
-f32=5
-```
-
-#### Enable RVV code-gen
-Through IREE's vectorization pass and LLVM backend, we can generate RVV
-VLS(Vector Length Specific) style codes.
-
-```shell
-$ ../iree-build-host/install/bin/iree-compile \
--iree-mlir-to-vm-bytecode-module \
--iree-hal-target-backends=dylib-llvm-aot \
--iree-input-type=mhlo \
--iree-llvm-target-triple=riscv64 \
--iree-llvm-target-cpu=sifive-7-rv64 \
--iree-llvm-target-abi=lp64d \
--iree-llvm-target-cpu-features="+m,+a,+d,+v" \
--riscv-v-vector-bits-min=256 -riscv-v-fixed-length-vector-lmul-max=8 \
-${PWD}/iree/samples/simple_embedding/simple_embedding_test.mlir -o /tmp/output-rvv.vmfb
-```
-
-Then run on the RISC-V QEMU:
-
-```shell
-$ ${QEMU_BIN} \
- -cpu rv64,x-v=true,x-k=true,vlen=256,elen=64,vext_spec=v1.0 \
- -L ${RISCV_TOOLCHAIN_ROOT}/sysroot/ \
- ../iree-build-riscv/iree/tools/iree-run-module --driver=dylib \
- --driver=dylib \
- --module_file=/tmp/output-rvv.vmfb \
- --entry_function=simple_mul \
- --function_input="4xf32=[1 2 3 4]" \
- --function_input="4xf32=[2 4 6 8]"
-```
diff --git a/docs/developers/get_started/getting_started_tensorflow.md b/docs/developers/get_started/getting_started_tensorflow.md
deleted file mode 100644
index 33d1feb..0000000
--- a/docs/developers/get_started/getting_started_tensorflow.md
+++ /dev/null
@@ -1,111 +0,0 @@
-# Getting Started with IREE TensorFlow Integrations
-
- NOTE: Iree's Python API is currently being reworked. Some of these
- instructions may be in a state of flux as they document the end state.
-
-## Prerequisites
-
-You should have already completed the
-[Python getting started guide](../get-started/getting-started-python). Install
-the TensorFlow pip package:
-
-```shell
-$ python -m pip install tf-nightly
-```
-
-## Obtaining IREE Integration Binaries
-
-IREE's compiler integrations into TensorFlow are mediated by standalone binaries
-that can be built individually or installed from a distribution. These binaries
-are: `iree-import-tf`, `iree-import-tflite`, and `iree-import-xla`. They are
-configured in the
-[iree_tf_compiler BUILD file](https://github.com/google/iree/blob/main/integrations/tensorflow/iree_tf_compiler/BUILD).
-You have a few options for how to obtain these binaries
-
-### Option 1. Building with Bazel
-
-TensorFlow only supports the Bazel build system. If building any parts of
-TensorFlow yourself, you must have a working `bazel` command on your path. See
-the relevant "OS with Bazel" [getting started](../get-started) doc for more
-information.
-
-> Warning:<br>
-> Building TF binaries takes a very long time,
-> especially on smallish machines (IREE devs that work on these typically use
-> machines with 96 cores)
-
-For example to run TensorFlow-based tests, you can build `iree-import-tf`
-
-```shell
-python3 configure_bazel.py
-cd integrations/tensorflow
-bazel build \
- //iree_tf_compiler:iree-import-tf \
- //iree_tf_compiler:iree-import-tflite \
- //iree_tf_compiler:iree-import-xla
-
-```
-
-The directory containing the binary will be printed (i.e.
-`bazel-bin/iree_tf_compiler/iree-import-tf`) and the parent directory must be
-passed to `-DIREE_TF_TOOLS_ROOT=` in a subsequent CMake invocation.
-
-### Option 2. Install from a release
-
-TODO(#4980): Document how this works
-
-Roughly:
-
-```shell
-python -m pip install \
- iree-tools-tf \
- iree-tools-tflite \
- iree-tools-xla \
- -f https://github.com/google/iree/releases
-```
-
-TODO: Need a more sophisticated mechanism than `IREE_TF_TOOLS_ROOT`, which
-only supports one directory. Also provide a tool to fetch and unpack
-release binaries.
-
-## Building
-
-The IREE Python bindings are only buildable with CMake. Continuing from above,
-to build with TensorFlow support, add `-DIREE_BUILD_TENSORFLOW_COMPILER=ON` to
-your invocation. If you obtained the integration binaries by a method other than
-building them with Bazel, you will also need to pass the path to the directory
-in which they are located: `-DIREE_TF_TOOLS_ROOT=path/to/dir` (it defaults to
-the location where the Bazel build creates them). From the IREE root directory:
-
-The following CMake flags control:
-
-* `-DIREE_BUILD_TENSORFLOW_COMPILER=ON`: build the TensorFlow integration.
-* `-DIREE_BUILD_TFLITE_COMPILER=ON`: build the TFLite integration.
-* `-DIREE_BUILD_XLA_COMPILER=ON`: build the XLA integration.
-* `-DIREE_TF_TOOLS_ROOT`: path to directory containing separately-built tools
- for the enabled integrations.
-
-```shell
-$ cmake -B ../iree-build-tf -G Ninja \
- -DIREE_BUILD_PYTHON_BINDINGS=ON \
- -DIREE_BUILD_TENSORFLOW_COMPILER=ON .
-$ cmake --build ../iree-build-tf
-```
-
-## Running Tests
-
-To run tests for the TensorFlow integration, which include end-to-end backend
-comparison tests:
-
-```shell
-$ cd ../iree-build-tf
-$ ctest -R 'tensorflow_e2e|bindings/python|integrations/tensorflow/' \
- --output-on-failure
-
-# Or run individually as:
-$ export PYTHONPATH=$(pwd)/bindings/python
-# This is a Python 3 program. On some systems, such as Debian derivatives,
-# use 'python3' instead of 'python'.
-$ python ../iree/integrations/tensorflow/e2e/simple_arithmetic_test.py \
- --target_backends=iree_vmvx --artifacts_dir=/tmp/artifacts
-```
diff --git a/docs/developers/get_started/getting_started_windows_cmake.md b/docs/developers/get_started/getting_started_windows_cmake.md
deleted file mode 100644
index 4967fd4..0000000
--- a/docs/developers/get_started/getting_started_windows_cmake.md
+++ /dev/null
@@ -1,156 +0,0 @@
-# Getting Started on Windows with CMake
-
-<!--
-Notes to those updating this guide:
-
- * This document should be __simple__ and cover essential items only.
- Notes for optional components should go in separate files.
-
- * This document parallels getting_started_linux_cmake.md and
- getting_started_macos_cmake.md
- Please keep them in sync.
--->
-
-This guide walks through building the core compiler and runtime parts of IREE
-from source. Auxiliary components like the Python bindings and Vulkan driver are
-documented separately, as they require further setup.
-
-## Prerequisites
-
-### Install CMake
-
-Install CMake version >= 3.13.4 from the
-[downloads page](https://cmake.org/download/).
-
-> Tip:<br>
-> Your editor of choice likely has plugins for CMake,
-> such as the Visual Studio Code
-> [CMake Tools](https://github.com/microsoft/vscode-cmake-tools) extension.
-
-### Install Ninja
-
-[Ninja](https://ninja-build.org/) is a fast build system that you can use as a
-CMake generator. Download it from the
-[releases page](https://github.com/ninja-build/ninja/releases), extract
-somewhere, and add it to your PATH.
-
-### Install a Compiler
-
-We recommend MSVC from either the full Visual Studio or from "Build Tools For
-Visual Studio":
-
-* Choose either option from the
- [downloads page](https://visualstudio.microsoft.com/downloads/) and during
- installation make sure you include "C++ Build Tools"
-* Initialize MSVC by running `vcvarsall.bat`:
-
- ```powershell
- > & "C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Auxiliary\Build\vcvars64.bat"
- ```
-
-## Clone and Build
-
-### Clone
-
-Using your shell of choice (such as PowerShell or [cmder](https://cmder.net/)),
-clone the repository and initialize its submodules:
-
-```powershell
-> git clone https://github.com/google/iree.git
-> cd iree
-> git submodule update --init
-```
-
-> Tip:<br>
-> Clone to a short path like `C:\projects\` to avoid
-> issues with Windows maximum path lengths (260 characters).
-
-> Tip:<br>
-> Editors and other programs can also clone the
-> repository, just make sure that they initialize the submodules.
-
-### Build
-
-Configure:
-
-```powershell
-> cmake -G Ninja -B ..\iree-build\ .
-```
-
-> Tip:<br>
-> The root
-> [CMakeLists.txt](https://github.com/google/iree/blob/main/CMakeLists.txt)
-> file has options for configuring which parts of the project to enable.<br>
-> These are further documented in [CMake Options and Variables](cmake_options_and_variables.md).
-
-Build all targets:
-
-```powershell
-> cmake --build ..\iree-build\
-```
-
-## Target Configuration
-
-### LLVM AOT Backend
-
-`-iree-hal-target-backends=dylib-llvm-aot` can be used to generate modules with
-ahead-of-time compiled kernels stored in DLLs. Run the iree-opt/iree-compile
-tools from a command prompt with `lld-link.exe` or `link.exe` tools on the
-`PATH` and the MSVC/Windows SDK environment variables; the easiest way to get
-this configured is to use the `vsvarsall.bat` or `vcvars64.bat` files to set
-your environment. See
-[the Microsoft documentation](https://docs.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=vs-2019)
-for details on configuring the toolchain.
-
-Translate a source MLIR file into an IREE module:
-
-```powershell
-> ..\iree-build\iree\tools\iree-compile.exe \
- -iree-mlir-to-vm-bytecode-module \
- -iree-hal-target-backends=dylib-llvm-aot \
- iree/samples/models/simple_abs.mlir \
- -o %TMP%/simple-llvm_aot.vmfb
-```
-
-Note that this will use the host machine as the target by default, and the
-exact target triple and architecture can be specified with flags when
-cross-compiling:
-
-```powershell
-> ..\iree-build\iree\tools\iree-compile.exe \
- -iree-mlir-to-vm-bytecode-module \
- -iree-hal-target-backends=dylib-llvm-aot \
- -iree-llvm-target-triple=x86_64-pc-windows-msvc \
- -iree-llvm-target-cpu=host \
- -iree-llvm-target-cpu-features=host \
- iree/samples/models/simple_abs.mlir \
- -o %TMP%/simple-llvm_aot.vmfb
-```
-
-## What's next?
-
-### Take a Look Around
-
-Check out the contents of the 'tools' build directory:
-
-```powershell
-> dir ..\iree-build\iree\tools
-> ..\iree-build\iree\tools\iree-compile.exe --help
-```
-
-Translate a
-[MLIR file](https://github.com/google/iree/blob/main/iree/samples/models/simple_abs.mlir)
-and execute a function in the compiled module:
-
-```powershell
-> ..\iree-build\iree\tools\iree-run-mlir.exe .\iree\samples\models\simple_abs.mlir -function-input="f32=-2" -iree-hal-target-backends=vmvx -print-mlir
-```
-
-### Further Reading
-
-* For an introduction to IREE's project structure and developer tools, see
- [Developer Overview](../developing_iree/developer_overview.md)
-* To target GPUs using Vulkan, see
- [Getting Started on Windows with Vulkan](getting_started_windows_vulkan.md)
-* To use IREE's Python bindings, see
- [Getting Started with Python](getting_started_python.md)
diff --git a/docs/developers/get_started/getting_started_windows_vulkan.md b/docs/developers/get_started/getting_started_windows_vulkan.md
deleted file mode 100644
index 0c544bf..0000000
--- a/docs/developers/get_started/getting_started_windows_vulkan.md
+++ /dev/null
@@ -1,156 +0,0 @@
-# Getting Started on Windows with Vulkan
-
-[Vulkan](https://www.khronos.org/vulkan/) is a new generation graphics and
-compute API that provides high-efficiency, cross-platform access to modern GPUs
-used in a wide variety of devices from PCs and consoles to mobile phones and
-embedded platforms.
-
-IREE includes a Vulkan/[SPIR-V](https://www.khronos.org/registry/spir-v/) HAL
-backend designed for executing advanced ML models in a deeply pipelined and
-tightly integrated fashion on accelerators like GPUs.
-
-This guide will walk you through using IREE's compiler and runtime Vulkan
-components. For generic Vulkan development environment set up and trouble
-shooting, please see [this doc](generic_vulkan_env_setup.md).
-
-## Prerequisites
-
-You should already have IREE cloned and building on your Windows machine. See
-the [Getting Started on Windows with CMake](getting_started_windows_cmake.md) or
-[Getting Started on Windows with Bazel](getting_started_windows_bazel.md) guide
-for instructions.
-
-You must have a physical GPU with drivers supporting Vulkan. We support using
-[SwiftShader](https://swiftshader.googlesource.com/SwiftShader/) (a high
-performance CPU-based implementation of Vulkan).
-
-Vulkan drivers implementing API version >= 1.2 are recommended. IREE requires
-the `VK_KHR_timeline_semaphore` extension (part of Vulkan 1.2), though it is
-able to emulate it, with performance costs, as necessary.
-
-## Vulkan Setup
-
-### Background
-
-Please see
-[Generic Vulkan Development Environment Setup and Troubleshooting](generic_vulkan_env_setup.md)
-for generic Vulkan concepts and development environment setup.
-
-### Quick Start
-
-The
-[dynamic_symbols_test](https://github.com/google/iree/blob/main/iree/hal/vulkan/dynamic_symbols_test.cc)
-checks if the Vulkan loader and a valid ICD are accessible.
-
-Run the test:
-
-```powershell
-# -- CMake --
-> set VK_LOADER_DEBUG=all
-> cmake --build ..\iree-build\ --target iree_hal_vulkan_dynamic_symbols_test
-> ..\iree-build\iree\hal\vulkan\iree_hal_vulkan_dynamic_symbols_test.exe
-
-# -- Bazel --
-> bazel test iree/hal/vulkan:dynamic_symbols_test --test_env=VK_LOADER_DEBUG=all
-```
-
-Tests in IREE's HAL "Conformance Test Suite" (CTS) actually exercise the Vulkan
-HAL, which includes checking for supported layers and extensions.
-
-Run the
-[driver test](https://github.com/google/iree/blob/main/iree/hal/cts/driver_test.cc):
-
-```powershell
-# -- CMake --
-> set VK_LOADER_DEBUG=all
-> cmake --build ..\iree-build\ --target iree_hal_vulkan_cts_vulkan_driver_test
-> ctest -R iree/hal/vulkan/cts/vulkan_driver_test
-```
-
-If these tests pass, you can skip down to the next section.
-
-### Setting up SwiftShader
-
-If your system lacks a physical GPU with compatible Vulkan drivers, or you just
-want to use a software driver for predictable performance, you can set up
-SwiftShader's Vulkan ICD (Installable Client Driver).
-
-IREE has a
-[helper script](https://github.com/google/iree/blob/main/build_tools/third_party/swiftshader/build_vk_swiftshader.sh)
-for building SwiftShader from source using CMake:
-
-```shell
-$ bash build_tools/third_party/swiftshader/build_vk_swiftshader.sh
-```
-
-<!-- TODO(scotttodd): Steps to download prebuilt binaries when they exist -->
-
-After building, the script will prompt your to add a variable `VK_ICD_FILENAMES`
-to your environment to tell the Vulkan loader to use the ICD. Assuming it was
-installed in the default location, this can be done via:
-
-```powershell
-> set VK_ICD_FILENAMES=%USERPROFILE%\.swiftshader\Windows\vk_swiftshader_icd.json
-```
-
-### Support in Bazel Tests
-
-Bazel tests run in a sandbox, which environment variables may be forwarded to
-using the `--test_env` flag. A user.bazelrc file using SwiftShader looks like
-this (substitute for the `{}` paths):
-
-```
-test --test_env="VK_ICD_FILENAMES={PATH_TO_IREE}\\build-swiftshader\\Windows\\vk_swiftshader_icd.json"
-```
-
-## Using IREE's Vulkan Compiler Target and Runtime Driver
-
-### Compiling for the Vulkan HAL
-
-Pass the flag `-iree-hal-target-backends=vulkan-spirv` to `iree-compile.exe`:
-
-```powershell
-# -- CMake --
-> cmake --build ..\iree-build\ --target iree_tools_iree-compile
-> ..\iree-build\iree\tools\iree-compile.exe -iree-mlir-to-vm-bytecode-module -iree-hal-target-backends=vulkan-spirv .\iree\tools\test\iree-run-module.mlir -o .\build\module.vmfb
-
-# -- Bazel --
-> bazel run iree/tools:iree-compile -- -iree-mlir-to-vm-bytecode-module -iree-hal-target-backends=vulkan-spirv .\iree\tools\test\iree-run-module.mlir -o .\build\module.vmfb
-```
-
-> Tip:<br>
-> If successful, this may have no output. You can pass
-> other flags like `-print-ir-after-all` to control the program.
-
-### Executing modules with the Vulkan driver
-
-Pass the flag `-driver=vulkan` to `iree-run-module.exe`:
-
-```powershell
-# -- CMake --
-> cmake --build ..\iree-build\ --target iree_tools_iree-run-module
-> ..\iree-build\iree\tools\iree-run-module.exe \
- --driver=vulkan \
- --module_file=.\build\module.vmfb \
- --entry_function=abs \
- --function_input=f32=-2
-
-# -- Bazel --
-> bazel run iree/tools:iree-run-module -- \
- --driver=vulkan \
- --module_file=.\build\module.vmfb \
- --entry_function=abs \
- --function_input=f32=-2
-```
-
-## Running IREE's Vulkan Samples
-
-> Note:<br>
-> The Vulkan samples are CMake-only.
-
-Install the [Vulkan SDK](https://www.lunarg.com/vulkan-sdk/), then run:
-
-```powershell
-> cmake --build ..\iree-build\ --target iree_samples_vulkan_vulkan_inference_gui
-> ..\iree-build\iree\samples\vulkan\vulkan_inference_gui.exe
-```
diff --git a/docs/developers/get_started/generic_vulkan_env_setup.md b/docs/developers/get_started/vulkan_environment_setup.md
similarity index 78%
rename from docs/developers/get_started/generic_vulkan_env_setup.md
rename to docs/developers/get_started/vulkan_environment_setup.md
index 13a68dd..4845fdc 100644
--- a/docs/developers/get_started/generic_vulkan_env_setup.md
+++ b/docs/developers/get_started/vulkan_environment_setup.md
@@ -98,6 +98,51 @@
This can also be done by sourcing the proper `setup-env.sh` from one of the
downloaded Vulkan SDKs.
+### Android
+
+Please make sure your Android device is Vulkan capable. Vulkan is supported on
+Android since 7, but we track newer Android versions (10+) closely and haven't
+set a clear min version yet.
+
+#### Troubleshooting Vulkan function `vkCreateInstance` not available
+
+Since Android 8 Oreo, Android re-architected the OS framework with
+[project Treble](https://source.android.com/devices/architecture#hidl).
+Framework libraries and
+[vendor libraries](https://source.android.com/devices/architecture/vndk) have a
+more strict and clear separation. Their dependencies are carefully scrutinized
+and only selected cases are allowed. This is enforced with
+[linker namespaces](https://source.android.com/devices/architecture/vndk/linker-namespace).
+
+`/data/local/tmp` is the preferred directory for automating native binary tests
+built using NDK toolchain. They should be allowed to access libraries like
+`libvulkan.so` for their functionality. However, there was an issue with fully
+treblized Android 10 where `/data/local/tmp` did not have access to the linker
+namespaces needed by `libvulkan.so`. This should be
+[fixed](https://android.googlesource.com/platform/system/linkerconfig/+/296da5b1eb88a3527ee76352c2d987f82f3252eb)
+now. But as typically in the Android system, it takes a long time to see the fix
+getting propagated, if ever.
+
+A known workaround is to symlink the vendor Vulkan implementation under
+`/vendor/lib[64]` as `libvulkan.so` under `/data/local/tmp` and use
+`LD_LIBRARY_PATH=/data/local/tmp` when invoking IREE executables.
+
+For Qualcomm Adreno GPUs, the vendor Vulkan implementation is at
+`/vendor/lib[64]/hw/vulkan.*.so`. So for example for Snapdragon 865:
+
+```shell
+$ adb shell ln -s /vendor/lib64/hw/vulkan.kona.so /data/local/tmp/libvulkan.so
+```
+
+For ARM Mali GPUs, there is only one monolithic driver
+(`/vendor/lib[64]/libGLES_mali.so`) for OpenGL and Vulkan and the Vulkan vendor
+driver (`/vendor/lib[64]/hw/vulkan.*.so`) is just a symlink to it. So for
+example:
+
+```shell
+$ adb shell ln -s /vendor/lib64/libGLES_mali.so /data/local/tmp/libvulkan.so
+```
+
## Vulkan debugging and profiling
### RenderDoc
