Merge branch 'main' into fw/mas_docs

Signed-off-by: Francis Williams <fwilliams@users.noreply.github.com>

Author: fwilliams

Dockerfile

@@ -1,22 +1,21 @@
-FROM condaforge/miniforge3:24.11.3-2
+FROM nvidia/cuda:12.8.1-cudnn-devel-ubuntu22.04
 
-ARG MODE=dev
-RUN echo "Building fVDB container in $MODE mode"
+# Set environment variables to prevent interactive prompts during installation.
+ENV DEBIAN_FRONTEND=noninteractive
 
-# used for cross-compilation in docker build
-ENV FORCE_CUDA=1
+RUN sed -i 's/archive.ubuntu.com/mirrors.ocf.berkeley.edu/g' /etc/apt/sources.list
 
-# Create and use a consistent workspace directory
-RUN mkdir -p /workspace
-WORKDIR /workspace
+# Install Python
+RUN apt-get update && \
+    apt-get install -y python3-pip python3-dev python3-venv python-is-python3 wget git ninja-build vim libxcb1-dev libx11-dev libgl-dev pkgconf && \
+    rm -rf /var/lib/apt/lists/* && \
+    python -m pip install --upgrade pip
 
-# Conda setup
-# force this CUDA version to be used to build the docker container because `docker build` does not
-# expose the GPU to the docker build process for it to be detected
-# fVDB team NOTE!!! We've tried removing this ENV line and it doesn't work, container build fails.
-ENV CONDA_OVERRIDE_CUDA=12.9
-COPY env/dev_environment.yml /tmp/
-RUN  conda env create -f /tmp/dev_environment.yml
+# Install CMake
+RUN mkdir ~/temp && \
+    cd ~/temp && \
+    wget -nv https://github.com/Kitware/CMake/releases/download/v4.1.2/cmake-4.1.2-linux-x86_64.sh && \
+    mkdir /opt/cmake && \
+    sh cmake-4.1.2-linux-x86_64.sh --prefix=/usr/local --skip-license && \
+    cmake --version
 
-RUN conda init
-RUN echo "conda activate fvdb" >> ~/.bashrc

README.md

@@ -21,35 +21,34 @@ Lastly, our [documentation](docs) provides deeper details on the concepts as wel
 
 ## Installing *f*VDB
 
-During the project's initial development stages, it is necessary to [run the build steps](#building-fvdb-from-source) to install ƒVDB. Eventually, ƒVDB will be provided as a pre-built, installable package from anaconda.  We support building the latest ƒVDB version for the following dependent library configurations:
+During the project's initial development stages, it is necessary to [run the build steps](#building-fvdb-from-source) to install ƒVDB. Eventually, ƒVDB will be provided as a pre-built, installable package. We support building the latest ƒVDB version for the following library configurations:
 
 |   PyTorch      | Python      | CUDA |
 | -------------- | ----------- | ------------ |
-|  2.4.0-2.4.1   | 3.10 - 3.12 | 12.1 - 12.4 |
+|  2.8.0-2.9.0   | 3.10 - 3.13 | 12.8 - 13.0 |
 
 
 
 ** Notes:**
-* Linux is the only platform currently supported (Ubuntu >= 20.04 recommended).
+* Linux is the only platform currently supported (Ubuntu >= 22.04 recommended).
 * A CUDA-capable GPU with Ampere architecture or newer (i.e. compute capability >=8.0) is recommended to run the CUDA-accelerated operations in ƒVDB.  A GPU with compute capabililty >=7.0 (Volta architecture) is the minimum requirement but some operations and data types are not supported.
 
 
 ## Building *f*VDB from Source
 
 ### Environment Management
-ƒVDB is a Python library implemented as a C++ Pytorch extension.  Of course you can build ƒVDB in whatever environment suits you, but we provide three paths to constructing reliable environments for building and running ƒVDB. These are separate options,
-choose only one. They're not intended to be used together.
+ƒVDB is a Python library implemented as a C++ PyTorch extension.  Of course you can build ƒVDB in whatever environment suits you, but we provide three distinct paths to constructing reliable environments for building and running ƒVDB. These are separate options and are not intended to be used together.
 
-1. **RECOMMENDED** [conda](#option-1-setting-up-a-conda-environment-recommended)
-2. Using [docker](#option-2-setting-up-a-docker-container)
-3. Python virtual environment. [venv](#option-3-setting-up-a-python-virtual-environment)
+1. **RECOMMENDED** [conda](#option-1-conda-environment-recommended)
+2. Using [Docker](#option-2-docker-container)
+3. [Python virtual environment](#option-3-python-virtual-environment)
 
 `conda` tends to be more flexible since reconfiguring toolchains and modules to suit your larger project can be dynamic, but at the same time this can be a more brittle experience compared to using a virtualized `docker` container.  Using `conda` is generally recommended for development and testing, while using `docker` is recommended for CI/CD and deployment.
 
 ---
 
 
-#### **OPTION 1** Setting up a Conda Environment (Recommended)
+#### **OPTION 1** Conda Environment (Recommended)
 
 *f*VDB can be used with any Conda distribution installed on your system. Below is an installation guide using
 [miniforge](https://github.com/conda-forge/miniforge). You can skip steps 1-3 if you already have a Conda installation.
@@ -84,56 +83,43 @@ conda activate fvdb
 
 ---
 
-#### **OPTION 2** Setting up a Docker Container
+#### **OPTION 2** Docker Container
 
-Running a docker container is a great way to ensure that you have a consistent environment for building and running ƒVDB.
+Running a Docker container ensures that you have a consistent environment for building and running ƒVDB. Start by installing Docker and the [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html).
 
-Our provided [`Dockerfile`](Dockerfile) constructs a Docker image which is ready to build ƒVDB.  The docker image is configured to install miniforge and the `fvdb` conda environment with all the dependencies needed to build and run ƒVDB.
+Our provided [`Dockerfile`](Dockerfile) constructs a container that pre-installs the dependencies needed to build and run ƒVDB.
 
-Building and starting the docker image is done by running the following command from the fvdb directory:
+In the fvdb-core directory, build the Docker image:
 ```shell
-docker compose run --rm fvdb-dev
+docker build -t fvdb-devel .
 ```
 
-
 When you are ready to build ƒVDB, run the following command within the docker container.  `TORCH_CUDA_ARCH_LIST` specifies which CUDA architectures to build for.
 ```shell
-conda activate fvdb;
+docker run -it --mount type=bind,src="$(pwd)",target=/workspace fvdb-devel bash
 cd /workspace;
-TORCH_CUDA_ARCH_LIST="7.5;8.0;8.6+PTX" \
-./build.sh install verbose
-```
-
-If you've built an artifact that you want to extract from the container, with "wheel" being the
-most useful... The built wheel can be extracted from the running docker image using `docker cp`, given the
-ID of the running image. For example:
-
-```shell
-docker cp fvdb-fvdb-dev-run-0123456789ab:/workspace/dist/fvdb-0.2.1-cp312-cp312-linux_x86_64.whl .
+pip install -r env/build_requirements.txt
+TORCH_CUDA_ARCH_LIST="7.5;8.0;9.0;10.0;12.0+PTX" \
+./build.sh install -v
 ```
 
-where `0123456789ab` is the ID of the running docker container, obtained via `docker ps`.
-
-Additional information about the ƒVDB docker setup, with troubleshooting for common errors, can be found
-here: [`ƒVDB Docker`](docs/markdown/docker_readme.md)
+In order to extract an artifact from the container such as the Python wheel, query the container ID using `docker ps` and copy the artifact using `docker cp`.
 
 ---
 
-#### **OPTION 3** Setting up a Python virtual environment
+#### **OPTION 3** Python Virtual Environment
 
-Create a python virtual environment and then proceed to install the exact version of PyTorch that corresponds to your CUDA version. Finally, install the rest of the build requirements.
+Using a Python virtual environment enables you to use your system provided compiler and CUDA toolkit. This can be especially useful if you are using ƒVDB in conjunction with other Python packages, especially packages that have been built from source. Start by installing GCC, the CUDA Toolkit, and cuDNN.
+
+Then, create a Python virtual environment, install the requisite dependencies, and build:
 
 ```shell
 python -m venv fvdb
 source fvdb/bin/activate
-pip install -r env/build_requirements.txt --extra-index-url https://download.pytorch.org/whl/cu129
+pip install -r env/build_requirements.txt
+TORCH_CUDA_ARCH_LIST="7.5;8.0;9.0;10.0;12.0+PTX" ./build.sh install -v
 ```
-
-When you're ready to build fVDB, run the following command after activating the Python virtual environment
-```shell
-TORCH_CUDA_ARCH_LIST="7.5;8.0;8.6+PTX" ./build.sh install
-```
-
+Note: adjust the TORCH_CUDA_ARCH_LIST to suit your needs. If you are building just to run on a single machine, including only the present GPU architecture(s) reduces build time.
 ---
 
 ### Building *f*VDB