# Run a recorded configuration on your server End-to-end command testing is complete, and this package is published on LocalAIServers.com for review. The reviewed capacity limitation and strict failures remain explicit in each row. Check the row’s Docker Hub command-validation column before treating a portable command as verified. The chart links to pinned runtime images on Docker Hub. Use the immutable `repository@sha256:…` reference shown in each row. A Docker image ID and a registry manifest digest are different identifiers; the release records both and verifies their relationship. The images contain the runtime and native kernels. They do **not** contain model weights, your Docker login, or a requirement for the original `/home/ai` or `/usr/share/ollama` host directories. Model inputs are acquired separately from pinned public revisions, verified by hash, and mounted read-only. ## Requirements - Linux x86-64 with Docker Engine and an amdgpu host driver compatible with the image's ROCm runtime. The image contains userspace ROCm; it does not install a host kernel driver. - The row's number of **nominal 32 GB MI50 (`gfx906`, PCI device `66a1`) or V620 (`gfx1030`, `73a1`) GPUs**. Driver-visible VRAM is about 32 GiB on the tested MI50s and 30 GiB on V620s because of firmware reservations. TP count alone does not make another GPU architecture compatible. - Full VRAM BAR / Above 4G decoding, automatic DPM and working GPU peer access. The launch tool checks only the render nodes you explicitly select and refuses occupied devices. It does not stop another service or change clock settings. - Enough host RAM and persistent storage for the selected model and fresh compilation caches. The tested systems had substantial host RAM; 128 GiB is a practical starting point for these models, not a proven minimum for every row. Keep at least 6 GiB free for each new run's caches/results, in addition to the model and Docker storage. A clean MI50 image install can need approximately 70–80 GB of Docker space including temporary compressed data; shared layers reduce subsequent downloads. V620 images are smaller. - The original serving and benchmark ports must be free. Current profiles use 8001 or 9002; their benchmark proxies use their pinned separate ports. Historical ports are in the original recovered settings. - `python3` 3.12, `sha256sum`, `tar`, `bash`, `curl`, `timeout` and a local Docker socket. Both end-to-end test hosts use Python 3.12.3; other host Python versions have not received this full validation. Run the commands on the Docker daemon host so bind paths refer to the same filesystem. The images and configurations have retained GPU results. The portable wrapper changes host paths, GPU identity selection, CPU/NUMA affinity and a new container name; it does not change native arithmetic, weights, quantization, TP/MTP, context, scorer or request content. Argument-mapping checks are separate from the current end-to-end tests. Five derived MI50 images replace only the original host-specific PCI allowlist; each row preserves its original measured image and numbers separately. Different hardware topology, driver, cache history or CPU affinity can change performance. Before a missing image is pulled, the launcher conservatively requires space for its full layer set plus compressed download and a 2 GiB margin. This can overestimate needs when shared layers already exist. You can pre-pull the exact digest yourself after checking actual Docker storage; the launcher then verifies that already installed image. It never prunes or deletes other images. ## Select paths and devices Download the archive and matching `.sha256` file named in each exact command. These packages are not interchangeable: - `launch-tools-r2.tar.gz`: unchanged mappings where the chart selects r2. - `launch-tools-mi50-r3.tar.gz`: the twelve MI50 TP2/TP4 mappings with the derived host-portability images. - `launch-tools-v620-r4.tar.gz`: nine V620 quantized benchmark commands with the actual-filesystem evidence check. - `launch-tools-v620-serve-r5.tar.gz`: thirteen V620 serving commands with a bounded wait for their own completed GPU probe to release its allocations before the unchanged idle check. No other service is stopped; no clock or numerical setting changes. - `launch-tools-historical-r6.tar.gz`: nineteen historical serving and benchmark recipes. The launcher reads both ports from each authenticated original recipe; row 29 uses 8078/19078 and the other rows use 8001/19080. A row can use different packages for serving and benchmarking. This current guide takes precedence over older documentation retained inside frozen source packages. Verify and extract the package named in the command, then run that command after editing its documented host choices. Choose your own persistent model directory. For current Qwen3.8 rows, `MODEL_DIR` is the checkpoint directory itself. For historical Qwen3.6 rows, it is the collection directory containing the exact `qwen36-dense`, `qwen36-moe` or `qwen36-gguf` inputs required by that row. Use the GPU render nodes that belong to the intended GPUs on **your** host. `renderD128,renderD129` in an example is a placeholder, not a claim about your host. The launcher resolves those nodes to their actual PCI addresses and card nodes. No lab PCI address, NUMA node or CPU number is assumed. The shared V620 posted-boundary host component was also inspected in all twelve active V620 images: it uses local ranks, actual peer capability and exchanged IPC handles, with no literal PCI address in the helper or shared library. [Inspection evidence](dockerhub-e2e/v620-posted-host-review.json). This is a bounded source/binary check; testing on a second physical V620 host has not been performed. Example after extraction and model acquisition: ```bash python3 launch-tools-mi50-r3/portable/launch.py \ --config mi50-w8-tp2-mtp0 \ --model /srv/models/pinned-Qwen3.8-checkpoint \ --work-dir /srv/runs/mi50-w8-tp2-example-01 \ --renders renderD128,renderD129 \ --serve ``` Replace all example paths and GPU nodes. Each work directory must be new. The tool verifies the pinned model, pulls the immutable registry digest, checks the image config/layer identities, and performs a selected-device architecture/peer-access preflight before serving. CPU affinity defaults to the calling process's allowed CPUs and has no NUMA restriction. Supply `--cpus 0-15` and optionally `--mems 0` only if those are appropriate on your server. These choices are recorded as environment differences. For benchmarks, do not compete with other workloads on the GPUs you select. ## Exact Docker commands and benchmark results Omit both `--serve` and `--benchmark` to prepare inputs and print the complete resolved `docker run` command without starting the service. Preparation performs a small selected-GPU compatibility probe; it does not run a model benchmark. The exact Docker argument array is saved as `docker-argv.json` in your work directory. Current configurations write `docker-run.sh` there; historical configurations write it under `run/docker-run.sh`. The chart retains earlier lab Docker commands and recovered launch sources as evidence. These are not all fully resolved commands from the original measurement: historical launch scripts and their source/result bindings were recovered, but complete original Docker inspections were not. Their lab paths and device numbering are not instructions to create those directories on your server. Use the current portable command; it records the full resolved Docker argument array for that actual launch. `--serve` leaves only its new service running. Use the printed health URL and `docker logs` with the saved exact container ID to monitor cold startup. Compilation can take tens of minutes, including compilation triggered by the first inference after the HTTP endpoint becomes ready. In the fresh-cache V620 FP16 TP4 validation, that first request took about 15 minutes after HTTP readiness. A successful models/health response alone does not verify inference. The caller controls when to stop that service. `--benchmark` starts a separate fresh cohort, uses the retained warmup/strict/fixed-token procedure, retains responses/counters, and stops only that new cohort. Use a different new work directory and free ports/devices. A completed runner does not imply a strict pass; read the retained strict and fixed-token audit verdicts. Known failed-strict rows and the V620 FP16 TP2/MTP capacity failure stay explicitly labeled. Publishing their runtime does not turn those results into valid serving baselines. The three unmeasured V620 TP8 rows have no invented image/configuration or result. ## Historical recipes Historical rows use recovered original launch inputs, model revisions and runtime overlays. Original privilege flags are preserved, including `--privileged` in recipes that used it. Those recipes require a trusted host; GPU visibility is not a security isolation boundary. The portable wrapper selects the supplied MI50s by their ROCr UUIDs and preserves the original local HIP ordinals. It refuses historical launch if the selected devices do not expose usable UUIDs. Fresh historical GPU reproductions are linked separately from original published scores. They do not retroactively establish the missing original measurement details. The chart preserves that distinction. ## Verification and publication See `credential-portability-audit.json`, `portable-command-validation.json`, `dockerhub-publication.json`, and `registry-content-verification.json`. The image scan covered every original layer, including deleted or overwritten contents, plus image configurations and history. Supporting downloadable assets were also scanned. All detected matches were reviewed; no project credentials were found. Two exact upstream public documentation/sandbox-CI token examples remain and are documented without exposing their values. The registry verification freshly downloaded each unique layer and checked both its compressed registry digest and its uncompressed original RootFS digest. Docker pull and CPU import tests were also performed. These checks do not claim a new GPU benchmark or identical speed on every server. The HTML, workbook and CSV use the same recorded numerical results. LocalAIServers.com publication remains pending owner approval. MI50 TP2/TP4 compatibility package: use the exact launch-tools-mi50-r3 command shown in its chart row. These five derived images replace a lab PCI-address allowlist in host initialization with actual distinct-device checks. GPU kernels, math, precision, grid, peer checks and timeout settings are unchanged. The original measured images remain published and are preserved separately in the chart. The other command packages have their own documented scope; use exactly the package selected by the chart. Historical serving and benchmark commands use `launch-tools-historical-r6`. Its launcher reads the server and proxy ports from the hash-checked original recipe: row 29 uses 8078/19078, while the other historical rows use 8001/19080. This fixes a missing proxy-port field in the portable wrapper; images, models, original ports and benchmark requests are unchanged. The earlier failed command remains in the validation evidence.