From 6424b88c15ba592580832a1e9666b1eb44ced9bb Mon Sep 17 00:00:00 2001 From: frank-2077 Date: Thu, 20 Aug 2026 14:22:35 +0000 Subject: [PATCH 01/28] feat(gemm): align BF16 K reduction with TP tree --- csrc/cuda/gemm/det_gemm_kernel.cu | 240 +++++++++++++++++++++++++++--- tests/test_det_gemm.py | 133 ++++++++++++++++- 2 files changed, 346 insertions(+), 27 deletions(-) diff --git a/csrc/cuda/gemm/det_gemm_kernel.cu b/csrc/cuda/gemm/det_gemm_kernel.cu index cd92fc9d..5459b2fe 100644 --- a/csrc/cuda/gemm/det_gemm_kernel.cu +++ b/csrc/cuda/gemm/det_gemm_kernel.cu @@ -6,16 +6,25 @@ // // SM90 path : TMA load + mma.sync (m16n8k16), FP32 accum, single-CTA-per-tile, // fixed K order, NO split-K -> batch-invariant. -// Fallback : naive FP32 scalar kernel (also the correctness ground truth). +// Fallback : naive scalar kernel (also the correctness ground truth). // -// Both: BF16 in / FP32 accum / no TF32 / no split-K. +// BF16-output entry points use BF16 inputs, FP32 leaf accumulation, BF16 tree +// nodes and store, no TF32, and no split-K. K is reduced with a canonical +// midpoint tree whose leaves cover at most 32 values. A contiguous half-K +// GEMM is therefore one child of the same tree, so TP shards can be combined +// with the matching balanced collective without changing the arithmetic +// graph. det_gemm_fwd_fp32 retains its ascending FP32 accumulation and FP32 +// output contract. // fwd: C = A @ B | dA = dC @ B^T | dB = A^T @ dC // Backward reuses the forward kernel on transposed operands. #include #include +#include #include +#include + #if defined(RL_KERNEL_ENABLE_SM90) #include "det_gemm_tma.cuh" #endif @@ -32,15 +41,108 @@ __device__ __forceinline__ nv_bf16 cast_output(float value) { return __float2bfloat16(value); } -template <> -__device__ __forceinline__ float cast_output(float value) { - return value; +__host__ __device__ constexpr int cdiv(int a, int b) { return (a + b - 1) / b; } + +// Keep this equal to the SM90 BK below. Each leaf accumulates in FP32 and is +// rounded to BF16 before the fixed midpoint tree combines it with its sibling. +constexpr int K_TREE_LEAF = 32; + +__device__ __forceinline__ nv_bf16 bf16_add(nv_bf16 lower, nv_bf16 upper) { + return __float2bfloat16( + __bfloat162float(lower) + __bfloat162float(upper)); } -__host__ __device__ constexpr int cdiv(int a, int b) { return (a + b - 1) / b; } +// True iff [lo, hi) is a node in the recursive midpoint partition of [0, n). +// The SM90 implementation consumes leaves in ascending order and uses this +// predicate to close exactly the same nodes as the scalar implementation. +__device__ __forceinline__ bool is_mid_split_node(int lo, int hi, int n) { + int begin = 0; + int end = n; + while (end - begin > 1) { + if (begin == lo && end == hi) { + return true; + } + const int midpoint = begin + (end - begin) / 2; + if (hi <= midpoint) { + end = midpoint; + } else if (lo >= midpoint) { + begin = midpoint; + } else { + return false; + } + } + return begin == lo && end == hi; +} + +// Evaluate the midpoint tree without device recursion. A depth of 32 covers +// every positive 32-bit K and is accepted by both NVCC and HIPCC without +// relocatable-device-code support. +__device__ nv_bf16 k_tree_naive( + const nv_bf16* __restrict__ A, + const nv_bf16* __restrict__ B, + int row, + int col, + int N, + int K) { + constexpr int MAX_TREE_DEPTH = 32; + int range_lo[MAX_TREE_DEPTH]; + int range_hi[MAX_TREE_DEPTH]; + unsigned char state[MAX_TREE_DEPTH]; + nv_bf16 left_value[MAX_TREE_DEPTH]; + + int depth = 0; + range_lo[0] = 0; + range_hi[0] = K; + state[0] = 0; + nv_bf16 value = __float2bfloat16(0.0f); + bool have_value = false; + + while (true) { + if (!have_value) { + const int lo = range_lo[depth]; + const int hi = range_hi[depth]; + if (hi - lo <= K_TREE_LEAF) { + float acc = 0.0f; + for (int k = lo; k < hi; ++k) { + acc += __bfloat162float(A[row * K + k]) * + __bfloat162float(B[k * N + col]); + } + value = __float2bfloat16(acc); + have_value = true; + } else { + const int midpoint = lo + (hi - lo) / 2; + state[depth] = 1; + ++depth; + range_lo[depth] = lo; + range_hi[depth] = midpoint; + state[depth] = 0; + } + continue; + } + + if (depth == 0) { + return value; + } + + --depth; + if (state[depth] == 1) { + left_value[depth] = value; + state[depth] = 2; + const int midpoint = + range_lo[depth] + (range_hi[depth] - range_lo[depth]) / 2; + ++depth; + range_lo[depth] = midpoint; + range_hi[depth] = range_hi[depth - 1]; + state[depth] = 0; + have_value = false; + } else { + value = bf16_add(left_value[depth], value); + } + } +} // Naive FP32 scalar kernel (fallback + ground truth). Batch-invariant by -// construction: one thread = one output element, fixed ascending K loop. +// construction: one thread = one output element, canonical midpoint K tree. constexpr int NAIVE_TILE = 16; template @@ -51,10 +153,19 @@ __global__ void det_gemm_naive(const nv_bf16* __restrict__ A, const int row = blockIdx.y * NAIVE_TILE + threadIdx.y; const int col = blockIdx.x * NAIVE_TILE + threadIdx.x; if (row >= M || col >= N) return; - float acc = 0.0f; - for (int k = 0; k < K; ++k) - acc += __bfloat162float(A[row * K + k]) * __bfloat162float(B[k * N + col]); - C[row * N + col] = cast_output(acc); + if constexpr (std::is_same_v) { + // Preserve det_gemm_fwd_fp32's existing FP32-output contract. The FFN + // path uses BF16 outputs and therefore takes the midpoint tree below. + float acc = 0.0f; + for (int k = 0; k < K; ++k) { + acc += __bfloat162float(A[row * K + k]) * + __bfloat162float(B[k * N + col]); + } + C[row * N + col] = acc; + } else { + C[row * N + col] = cast_output( + __bfloat162float(k_tree_naive(A, B, row, col, N, K))); + } } template @@ -72,6 +183,8 @@ void launch_naive(const nv_bf16* A, const nv_bf16* B, output_t* C, // passing B^T ([N,K] row-major) so the B smem tile is [BN,BK] (row=n,col=k), // matching the validated logp ldmatrix addressing. constexpr int BM = 128, BN = 64, BK = 32; +static_assert(BK == K_TREE_LEAF, + "SM90 tile width must match the scalar K-tree leaf"); constexpr int WARPS = 4; constexpr int WG_THREADS = WARPS * 32; // 128 constexpr int STAGES = 2; @@ -82,6 +195,7 @@ constexpr int M_TILES = WARP_M / MMA_M; // 1 constexpr int N_TILES = BN / MMA_N; // 8 constexpr int K_TILES = BK / MMA_K; // 2 constexpr int KK_GROUPS = BK / 32; // 1 +constexpr int TREE_DEPTH = 16; __device__ __forceinline__ void ldmatrix_x4(uint32_t regs[4], uint32_t addr) { asm volatile("ldmatrix.sync.aligned.m8n8.x4.shared.b16 {%0,%1,%2,%3}, [%4];" @@ -142,6 +256,12 @@ __global__ void det_gemm_sm90_kernel(const __grid_constant__ CUtensorMap a_tmap, for (int s = 0; s < STAGES; ++s) phase[s] = 0; float acc[M_TILES][N_TILES][4]; + float tile_acc[M_TILES][N_TILES][4]; + nv_bf16 tree_value[M_TILES][N_TILES][4]; + nv_bf16 tree_stack[TREE_DEPTH][M_TILES][N_TILES][4]; + int tree_lo[TREE_DEPTH]; + int tree_hi[TREE_DEPTH]; + int tree_stack_size = 0; #pragma unroll for (int mi = 0; mi < M_TILES; ++mi) #pragma unroll @@ -153,7 +273,7 @@ __global__ void det_gemm_sm90_kernel(const __grid_constant__ CUtensorMap a_tmap, for (int s = 0; s < STAGES - 1; ++s) if (s < kd) issue_load(s); - for (int k = 0; k < kd; ++k) { // fixed ascending K order, NO split-K + for (int k = 0; k < kd; ++k) { // fixed ascending tile order, NO split-K const int buf = k % STAGES; if (tid == 0 && k + (STAGES - 1) < kd) issue_load(k + (STAGES - 1)); det_gemm::mbar_wait(mbar[buf], phase[buf]); @@ -163,6 +283,18 @@ __global__ void det_gemm_sm90_kernel(const __grid_constant__ CUtensorMap a_tmap, const uint32_t sA_buf = sA_base + buf * BM * BK * sizeof(nv_bf16); const uint32_t sB_buf = sB_base + buf * BN * BK * sizeof(nv_bf16); + if constexpr (!std::is_same_v) { +#pragma unroll + for (int mi = 0; mi < M_TILES; ++mi) +#pragma unroll + for (int n = 0; n < N_TILES; ++n) { + tile_acc[mi][n][0] = 0.0f; + tile_acc[mi][n][1] = 0.0f; + tile_acc[mi][n][2] = 0.0f; + tile_acc[mi][n][3] = 0.0f; + } + } + uint32_t A[M_TILES][K_TILES][4]; #pragma unroll for (int mi = 0; mi < M_TILES; ++mi) { @@ -187,12 +319,62 @@ __global__ void det_gemm_sm90_kernel(const __grid_constant__ CUtensorMap a_tmap, const uint32_t B1[2] = {b4[2], b4[3]}; #pragma unroll for (int mi = 0; mi < M_TILES; ++mi) { - mma_m16n8k16(A[mi][2 * kk + 0], B0, acc[mi][n]); - mma_m16n8k16(A[mi][2 * kk + 1], B1, acc[mi][n]); + if constexpr (std::is_same_v) { + mma_m16n8k16(A[mi][2 * kk + 0], B0, acc[mi][n]); + mma_m16n8k16(A[mi][2 * kk + 1], B1, acc[mi][n]); + } else { + mma_m16n8k16(A[mi][2 * kk + 0], B0, tile_acc[mi][n]); + mma_m16n8k16(A[mi][2 * kk + 1], B1, tile_acc[mi][n]); + } } } } __syncthreads(); + + if constexpr (!std::is_same_v) { +#pragma unroll + for (int mi = 0; mi < M_TILES; ++mi) +#pragma unroll + for (int n = 0; n < N_TILES; ++n) +#pragma unroll + for (int value_index = 0; value_index < 4; ++value_index) { + tree_value[mi][n][value_index] = + __float2bfloat16(tile_acc[mi][n][value_index]); + } + + int lo = k; + const int hi = k + 1; + while (tree_stack_size > 0 && + tree_hi[tree_stack_size - 1] == lo && + is_mid_split_node(tree_lo[tree_stack_size - 1], hi, kd)) { +#pragma unroll + for (int mi = 0; mi < M_TILES; ++mi) +#pragma unroll + for (int n = 0; n < N_TILES; ++n) +#pragma unroll + for (int value_index = 0; value_index < 4; ++value_index) { + tree_value[mi][n][value_index] = bf16_add( + tree_stack[tree_stack_size - 1][mi][n][value_index], + tree_value[mi][n][value_index]); + } + lo = tree_lo[tree_stack_size - 1]; + --tree_stack_size; + } + if (hi < kd) { +#pragma unroll + for (int mi = 0; mi < M_TILES; ++mi) +#pragma unroll + for (int n = 0; n < N_TILES; ++n) +#pragma unroll + for (int value_index = 0; value_index < 4; ++value_index) { + tree_stack[tree_stack_size][mi][n][value_index] = + tree_value[mi][n][value_index]; + } + tree_lo[tree_stack_size] = lo; + tree_hi[tree_stack_size] = hi; + ++tree_stack_size; + } + } } #pragma unroll @@ -202,12 +384,22 @@ __global__ void det_gemm_sm90_kernel(const __grid_constant__ CUtensorMap a_tmap, for (int n = 0; n < N_TILES; ++n) { const int col = col_base + n * MMA_N + (lane % 4) * 2; if (row < M && col + 1 < N) { - C[row * N + col + 0] = cast_output(acc[mi][n][0]); - C[row * N + col + 1] = cast_output(acc[mi][n][1]); + if constexpr (std::is_same_v) { + C[row * N + col + 0] = acc[mi][n][0]; + C[row * N + col + 1] = acc[mi][n][1]; + } else { + C[row * N + col + 0] = tree_value[mi][n][0]; + C[row * N + col + 1] = tree_value[mi][n][1]; + } } if (row + 8 < M && col + 1 < N) { - C[(row + 8) * N + col + 0] = cast_output(acc[mi][n][2]); - C[(row + 8) * N + col + 1] = cast_output(acc[mi][n][3]); + if constexpr (std::is_same_v) { + C[(row + 8) * N + col + 0] = acc[mi][n][2]; + C[(row + 8) * N + col + 1] = acc[mi][n][3]; + } else { + C[(row + 8) * N + col + 0] = tree_value[mi][n][2]; + C[(row + 8) * N + col + 1] = tree_value[mi][n][3]; + } } } } @@ -216,7 +408,10 @@ __global__ void det_gemm_sm90_kernel(const __grid_constant__ CUtensorMap a_tmap, template bool launch_sm90(const nv_bf16* A, const nv_bf16* Bt, output_t* C, int M, int N, int K, cudaStream_t stream) { - if (M % BM != 0 || N % BN != 0 || K % BK != 0) return false; // fall back + if (M % BM != 0 || N % BN != 0 || K == 0 || K % BK != 0 || + K / BK > (1 << TREE_DEPTH)) { + return false; // fall back + } CUtensorMap a_tmap, bt_tmap; det_gemm::init_tmap_noswizzle(&a_tmap, A, M, K, BM, BK); @@ -251,6 +446,13 @@ void check_in(const torch::Tensor& t, const char* n) { torch::Tensor gemm_dispatch(const torch::Tensor& a, const torch::Tensor& b, bool output_fp32 = false) { + TORCH_CHECK( + a.device() == b.device(), + "deterministic GEMM inputs must be on the same device, got ", + a.device(), + " and ", + b.device()); + const at::cuda::OptionalCUDAGuard device_guard(at::device_of(a)); const int M = a.size(0), K = a.size(1), N = b.size(1); auto options = a.options().dtype(output_fp32 ? torch::kFloat32 : torch::kBFloat16); auto c = torch::empty({M, N}, options); diff --git a/tests/test_det_gemm.py b/tests/test_det_gemm.py index 42b73e1d..159eddb4 100644 --- a/tests/test_det_gemm.py +++ b/tests/test_det_gemm.py @@ -7,11 +7,12 @@ The PyTorch path (torch.matmul) is intentionally NOT tested here: it is the non-deterministic reference baseline and would fail batch-invariance by design. """ + import pytest import torch from rl_engine.kernels.gtest.tolerance import load_contract -from rl_engine.kernels.ops.cuda.matmul import deterministic_gemm +from rl_engine.kernels.ops.cuda.matmul import DetGemmOp, deterministic_gemm try: from rl_engine.kernels.ops.triton.matmul import deterministic_gemm_triton @@ -22,14 +23,19 @@ torch.backends.cuda.matmul.allow_tf32 = False DEV = "cuda" +IS_ROCM = getattr(torch.version, "hip", None) is not None +HAS_SUPPORTED_GPU = torch.cuda.is_available() and ( + IS_ROCM or torch.cuda.get_device_capability()[0] >= 8 +) pytestmark = pytest.mark.skipif( - not torch.cuda.is_available() or torch.cuda.get_device_capability()[0] < 8, - reason="det_gemm requires CUDA SM80+", + not HAS_SUPPORTED_GPU, + reason="det_gemm requires a ROCm GPU or CUDA SM80+", ) # Each deterministic backend is validated independently. -_BACKENDS = [("cuda", deterministic_gemm)] +_NATIVE_BACKEND = "rocm" if IS_ROCM else "cuda" +_BACKENDS = [(_NATIVE_BACKEND, deterministic_gemm)] if _HAS_TRITON: _BACKENDS.append(("triton", deterministic_gemm_triton)) @@ -38,6 +44,72 @@ def _rand(*shape): return torch.randn(*shape, device=DEV, dtype=torch.bfloat16) +_K_TREE_LEAF = 32 + + +def _k_tree_gemm(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor: + """Canonical FP32-leaf/BF16-node midpoint tree used by the native kernel.""" + + a = a.detach().contiguous() + b = b.detach().contiguous() + + def reduce_range(lo: int, hi: int) -> torch.Tensor: + if hi - lo <= _K_TREE_LEAF: + return (a[:, lo:hi].float() @ b[lo:hi, :].float()).to(torch.bfloat16) + midpoint = lo + (hi - lo) // 2 + return reduce_range(lo, midpoint) + reduce_range(midpoint, hi) + + return reduce_range(0, a.size(1)) + + +def _balanced_tree_sum(parts: list[torch.Tensor]) -> torch.Tensor: + level = parts + while len(level) > 1: + level = [level[index] + level[index + 1] for index in range(0, len(level), 2)] + return level[0] + + +@pytest.mark.parametrize("tp_size", (2, 4, 8)) +def test_forward_matches_balanced_contiguous_k_shards_bitwise(tp_size): + """The GEMM K-tree and the TP collective rank tree must be the same graph.""" + + torch.manual_seed(8) + # Qwen3-8B's down projection uses K=12288. Its 384 32-wide leaves also + # exercise the non-power-of-two midpoint tree used by the SM90 kernel. + m, k, n = 4, 12288, 64 + a, b = _rand(m, k), _rand(k, n) + width = k // tp_size + parts = [ + deterministic_gemm( + a[:, rank * width : (rank + 1) * width].contiguous(), + b[rank * width : (rank + 1) * width].contiguous(), + ) + for rank in range(tp_size) + ] + + full = deterministic_gemm(a, b) + sharded = _balanced_tree_sum(parts) + assert torch.equal(full, sharded), ( + f"full GEMM differed from balanced TP={tp_size} shards at " + f"{int((full != sharded).sum().item())} elements" + ) + + +@pytest.mark.skipif(torch.cuda.device_count() < 2, reason="requires two GPUs") +def test_forward_uses_the_input_device_when_it_is_not_current(): + original_device = torch.cuda.current_device() + input_device = (original_device + 1) % torch.cuda.device_count() + with torch.cuda.device(input_device): + a, b = _rand(4, 64), _rand(64, 32) + + assert torch.cuda.current_device() == original_device + output = deterministic_gemm(a, b) + + assert output.device.index == input_device + assert torch.isfinite(output).all() + assert torch.cuda.current_device() == original_device + + @pytest.mark.parametrize("name,gemm", _BACKENDS) def test_forward_batch_invariance(name, gemm): # A row's output must not change when other rows join the batch. @@ -81,12 +153,38 @@ def test_forward_correctness(name, gemm): M, K, N = 128, 2048, 2048 a, b = _rand(M, K), _rand(K, N) out = gemm(a, b).float() - ref = a.float() @ b.float() + ref = _k_tree_gemm(a, b).float() if name == _NATIVE_BACKEND else a.float() @ b.float() contract = load_contract() thresholds = contract["accuracy"]["default"]["reduction"]["bfloat16"] torch.testing.assert_close(out, ref, atol=thresholds["atol"], rtol=thresholds["rtol"]) +def test_native_forward_retains_reasonable_fp32_accuracy(): + """BF16 tree nodes may drift near zero but keep scale-normalized error small.""" + + torch.manual_seed(45) + m, k, n = 64, 4096, 512 + a, b = _rand(m, k), _rand(k, n) + output = deterministic_gemm(a, b).float() + reference = a.float() @ b.float() + relative_l2_error = ( + torch.linalg.vector_norm(output - reference) / torch.linalg.vector_norm(reference) + ).item() + + # K=4096 has 128 FP32 leaves and seven BF16-add levels. The 0.7% bound + # leaves margin over the measured ~0.5% while remaining scale-independent. + assert relative_l2_error < 7e-3 + + +def test_forward_fp32_preserves_its_public_dtype_contract(): + torch.manual_seed(46) + a, b = _rand(8, 64), _rand(64, 32) + output = DetGemmOp().forward_fp32(a, b) + + assert output.dtype is torch.float32 + assert output.shape == (8, 32) + + @pytest.mark.parametrize("name,gemm", _BACKENDS) def test_backward_batch_invariance(name, gemm): # dA for a row must be invariant to the surrounding batch. @@ -111,6 +209,25 @@ def test_backward_correctness(name, gemm): b = _rand(K, N).requires_grad_(True) g = _rand(M, N) gemm(a, b).backward(g) + if name == _NATIVE_BACKEND: + expected_da = _k_tree_gemm(g, b.detach().t().contiguous()) + expected_db = _k_tree_gemm(a.detach().t().contiguous(), g) + contract = load_contract() + thresholds = contract["accuracy"]["default"]["reduction"]["bfloat16"] + torch.testing.assert_close( + a.grad.float(), + expected_da.float(), + atol=thresholds["atol"], + rtol=thresholds["rtol"], + ) + torch.testing.assert_close( + b.grad.float(), + expected_db.float(), + atol=thresholds["atol"], + rtol=thresholds["rtol"], + ) + return + af = a.detach().float().requires_grad_(True) bf = b.detach().float().requires_grad_(True) (af @ bf).backward(g.float()) @@ -143,9 +260,9 @@ def test_target_shapes_invariance(name, gemm, shape): row = _rand(1, K) big = _rand(64, K) big[0] = row[0] - assert torch.equal( - gemm(row, b)[0], gemm(big, b)[0] - ), f"{name}: batch-invariance broken at shape {shape}" + assert torch.equal(gemm(row, b)[0], gemm(big, b)[0]), ( + f"{name}: batch-invariance broken at shape {shape}" + ) @pytest.mark.skipif(not _HAS_TRITON, reason="Triton is unavailable") From 6c02774e971b1947f136d5c7bf6d2505baf95638 Mon Sep 17 00:00:00 2001 From: frank-2077 Date: Thu, 20 Aug 2026 14:26:13 +0000 Subject: [PATCH 02/28] feat(distributed): add ROCm transport-only deterministic collectives --- rl_engine/distributed/__init__.py | 12 +- .../distributed/transport_collectives.py | 378 ++++++++++++++++++ ...test_transport_deterministic_collective.py | 329 +++++++++++++++ 3 files changed, 718 insertions(+), 1 deletion(-) create mode 100644 rl_engine/distributed/transport_collectives.py create mode 100644 tests/distributed/test_transport_deterministic_collective.py diff --git a/rl_engine/distributed/__init__.py b/rl_engine/distributed/__init__.py index 37698f1a..f83f2520 100644 --- a/rl_engine/distributed/__init__.py +++ b/rl_engine/distributed/__init__.py @@ -2,5 +2,15 @@ # Copyright (c) 2026 RL-Kernel Contributors from rl_engine.distributed.collectives import DeterministicCollective +from rl_engine.distributed.transport_collectives import ( + RCCLDeterministicCollective, + TorchDistributedDeterministicCollective, + create_deterministic_collective, +) -__all__ = ["DeterministicCollective"] +__all__ = [ + "DeterministicCollective", + "RCCLDeterministicCollective", + "TorchDistributedDeterministicCollective", + "create_deterministic_collective", +] diff --git a/rl_engine/distributed/transport_collectives.py b/rl_engine/distributed/transport_collectives.py new file mode 100644 index 00000000..e0261f48 --- /dev/null +++ b/rl_engine/distributed/transport_collectives.py @@ -0,0 +1,378 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 RL-Kernel Contributors +"""Deterministic reductions built on rank-ordered tensor transport. + +The transport in this module never performs a floating-point reduction. It +only gathers every rank's input, after which each rank evaluates the same +balanced reduction tree locally. In a ROCm build, PyTorch's ``nccl`` backend +is RCCL and therefore ``all_gather_into_tensor`` provides the transport. +""" + +from __future__ import annotations + +import threading +from types import TracebackType +from typing import Any + +import torch +import torch.distributed as dist + +_SUPPORTED_WORLD_SIZES = (1, 2, 4, 8) +_DEFAULT_MAX_SIZE_BYTES = 64 * 1024 * 1024 +_REDUCTION_DTYPES = (torch.float32, torch.float16, torch.bfloat16) + + +class TorchDistributedDeterministicCollective: + """Correctness-first collectives using AllGather as transport only. + + Rank inputs are gathered without arithmetic and reduced locally as the + balanced tree ``((rank0 + rank1) + (rank2 + rank3)) + ...``. Consequently, + all ranks execute the exact same floating-point expression. TP sizes 1, + 2, 4, and 8 are nested prefixes of that expression and match the existing + CUDA IPC collective's ordering. + + The generic class also supports a CPU/Gloo process group, which is useful + as an executable reference. Production ROCm callers should use + :class:`RCCLDeterministicCollective` or + :func:`create_deterministic_collective` so backend validation fails closed. + All ranks must call methods in the same order with matching input shapes + and dtypes, and construct the instance with the same ``max_size_bytes``. + """ + + backend_id = "torch_distributed_balanced_tree" + transport_only = True + reduction_order = "balanced_rank_tree" + + def __init__( + self, + group: dist.ProcessGroup | None = None, + device: torch.device | str | int | None = None, + *, + max_size_bytes: int = _DEFAULT_MAX_SIZE_BYTES, + ) -> None: + if not dist.is_available() or not dist.is_initialized(): + raise RuntimeError("torch.distributed must be initialized before collectives") + if max_size_bytes <= 0: + raise ValueError("max_size_bytes must be positive") + + self.group = group if group is not None else dist.group.WORLD + self.rank = int(dist.get_rank(group=self.group)) + self.world_size = int(dist.get_world_size(group=self.group)) + if self.world_size not in _SUPPORTED_WORLD_SIZES: + raise ValueError( + "deterministic collectives require world_size in " + f"{_SUPPORTED_WORLD_SIZES}, got {self.world_size}" + ) + + self.device = self._normalize_device(device) + self.max_size_bytes = int(max_size_bytes) + self._backend = str(dist.get_backend(self.group)).lower() + self._lock = threading.Lock() + self._closed = False + self._validate_matching_capacity() + + @staticmethod + def _normalize_device( + device: torch.device | str | int | None, + ) -> torch.device: + if device is None: + if torch.cuda.is_available(): + normalized = torch.device("cuda", torch.cuda.current_device()) + else: + normalized = torch.device("cpu") + elif isinstance(device, int): + normalized = torch.device("cuda", device) + else: + normalized = torch.device(device) + + if normalized.type == "cuda": + if not torch.cuda.is_available(): + raise RuntimeError("a CUDA/ROCm device was requested but none is available") + current_device = torch.cuda.current_device() + if normalized.index is None: + normalized = torch.device("cuda", current_device) + if normalized.index != current_device: + raise ValueError( + "the collective device must be the current CUDA/ROCm device; call " + f"torch.cuda.set_device({normalized.index}) first" + ) + return normalized + + @property + def closed(self) -> bool: + """Whether this instance rejects further collective calls.""" + + return self._closed + + def all_reduce( + self, + input: torch.Tensor, + *, + out: torch.Tensor | None = None, + ) -> torch.Tensor: + """Return the fixed balanced-tree sum on every rank.""" + + self._check_open() + self._validate_reduction_input(input) + if out is None: + out = torch.empty_like(input) + self._validate_output(out, input, tuple(input.shape)) + + with self._lock: + self._check_open() + self._validate_matching_signature("all_reduce", input) + rank_inputs = self._all_gather_transport(input) + reduced = self._balanced_tree_sum(rank_inputs) + out.copy_(reduced) + return out + + def all_gather( + self, + input: torch.Tensor, + *, + out: torch.Tensor | None = None, + ) -> torch.Tensor: + """Gather rank-ordered input bit patterns along dimension 0.""" + + self._check_open() + self._validate_gather_input(input) + output_shape = (input.size(0) * self.world_size, *input.shape[1:]) + if out is None: + out = torch.empty(output_shape, dtype=input.dtype, device=input.device) + self._validate_output(out, input, output_shape) + + with self._lock: + self._check_open() + self._validate_matching_signature("all_gather", input) + rank_inputs = self._all_gather_transport(input) + out.copy_(rank_inputs.reshape(output_shape)) + return out + + def reduce_scatter( + self, + input: torch.Tensor, + *, + out: torch.Tensor | None = None, + ) -> torch.Tensor: + """Fixed-tree sum followed by rank-ordered dimension-0 slicing.""" + + self._check_open() + self._validate_reduction_input(input) + if input.dim() == 0: + raise ValueError("reduce_scatter input must have at least one dimension") + if input.size(0) % self.world_size != 0: + raise ValueError( + "reduce_scatter input.size(0) must be divisible by " + f"world_size={self.world_size}; got {input.size(0)}" + ) + rows_per_rank = input.size(0) // self.world_size + output_shape = (rows_per_rank, *input.shape[1:]) + if out is None: + out = torch.empty(output_shape, dtype=input.dtype, device=input.device) + self._validate_output(out, input, output_shape) + + with self._lock: + self._check_open() + self._validate_matching_signature("reduce_scatter", input) + rank_inputs = self._all_gather_transport(input) + reduced = self._balanced_tree_sum(rank_inputs) + begin = self.rank * rows_per_rank + out.copy_(reduced.narrow(0, begin, rows_per_rank)) + return out + + def close(self) -> None: + """Close the instance. + + The AllGather implementation owns no persistent device allocation, so + closing is an idempotent lifecycle boundary rather than a transport + synchronization operation. + """ + + with self._lock: + self._closed = True + + def __enter__(self) -> TorchDistributedDeterministicCollective: + self._check_open() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + self.close() + + def __del__(self) -> None: + try: + self.close() + except Exception: + pass + + def _check_open(self) -> None: + if getattr(self, "_closed", True): + raise RuntimeError("deterministic collective is closed") + + def _validate_tensor(self, input: torch.Tensor) -> None: + if not isinstance(input, torch.Tensor): + raise TypeError(f"input must be a torch.Tensor, got {type(input)!r}") + if input.device != self.device: + raise ValueError(f"input must be on {self.device}, got {input.device}") + if not input.is_contiguous(): + raise ValueError("input must be contiguous") + input_bytes = input.numel() * input.element_size() + if input_bytes > self.max_size_bytes: + raise ValueError( + f"input requires {input_bytes} bytes but max_size_bytes={self.max_size_bytes}" + ) + + def _validate_reduction_input(self, input: torch.Tensor) -> None: + self._validate_tensor(input) + if input.dtype not in _REDUCTION_DTYPES: + raise TypeError( + "deterministic reductions support float32, float16, and bfloat16; " + f"got {input.dtype}" + ) + + def _validate_gather_input(self, input: torch.Tensor) -> None: + self._validate_tensor(input) + if input.dim() == 0: + raise ValueError("all_gather input must have at least one dimension") + + @staticmethod + def _validate_output( + output: torch.Tensor, + input: torch.Tensor, + output_shape: tuple[int, ...], + ) -> None: + if not isinstance(output, torch.Tensor): + raise TypeError(f"out must be a torch.Tensor, got {type(output)!r}") + if output.device != input.device: + raise ValueError("out must be on the same device as input") + if output.dtype != input.dtype: + raise TypeError("out must have the same dtype as input") + if tuple(output.shape) != output_shape: + raise ValueError(f"out must have shape {output_shape}, got {tuple(output.shape)}") + if not output.is_contiguous(): + raise ValueError("out must be contiguous") + + def _validate_matching_signature(self, op_name: str, input: torch.Tensor) -> None: + if self.world_size == 1: + return + signature = (op_name, tuple(input.shape), str(input.dtype), input.numel()) + signatures: list[tuple[Any, ...] | None] = [None] * self.world_size + dist.all_gather_object(signatures, signature, group=self.group) + if any(peer_signature != signature for peer_signature in signatures): + raise ValueError( + f"all ranks must call {op_name} with matching shapes and dtypes; got {signatures}" + ) + + def _validate_matching_capacity(self) -> None: + if self.world_size == 1: + return + capacities: list[int | None] = [None] * self.world_size + dist.all_gather_object(capacities, self.max_size_bytes, group=self.group) + if any(peer_capacity != self.max_size_bytes for peer_capacity in capacities): + raise ValueError(f"all ranks must use the same max_size_bytes; got {capacities}") + + def _all_gather_transport(self, input: torch.Tensor) -> torch.Tensor: + # Flattening makes the output contract independent of whether a given + # ProcessGroup implements the concatenation or stacking form of AG. + if self.world_size == 1: + return input.clone().reshape((1, *input.shape)) + input_flat = input.view(-1) + gathered_flat = torch.empty( + self.world_size * input_flat.numel(), + dtype=input.dtype, + device=input.device, + ) + if "nccl" in self._backend: + # PyTorch exposes RCCL through the NCCL ProcessGroup API. Keep + # this as a tensor-only transport; reduction happens below. + dist.all_gather_into_tensor(gathered_flat, input_flat, group=self.group) + else: + # Some reference backends (notably Gloo versions without + # all_gather_into_tensor) only implement the list API. + gathered_chunks = list( + gathered_flat.reshape(self.world_size, input_flat.numel()).unbind(0) + ) + dist.all_gather(gathered_chunks, input_flat, group=self.group) + return gathered_flat.reshape((self.world_size, *input.shape)) + + @staticmethod + def _balanced_tree_sum(rank_inputs: torch.Tensor) -> torch.Tensor: + level = list(rank_inputs.unbind(0)) + if len(level) not in _SUPPORTED_WORLD_SIZES: + raise ValueError( + "balanced reduction requires rank inputs for world_size in " + f"{_SUPPORTED_WORLD_SIZES}, got {len(level)}" + ) + while len(level) > 1: + level = [torch.add(level[index], level[index + 1]) for index in range(0, len(level), 2)] + return level[0] + + +class RCCLDeterministicCollective(TorchDistributedDeterministicCollective): + """ROCm collective using RCCL AllGather strictly as tensor transport.""" + + backend_id = "rccl_all_gather_balanced_tree" + + def __init__( + self, + group: dist.ProcessGroup | None = None, + device: torch.device | str | int | None = None, + *, + max_size_bytes: int = _DEFAULT_MAX_SIZE_BYTES, + ) -> None: + if getattr(torch.version, "hip", None) is None: + raise RuntimeError("RCCL deterministic collectives require a ROCm PyTorch build") + if not torch.cuda.is_available(): + raise RuntimeError("RCCL deterministic collectives require an available ROCm device") + super().__init__(group=group, device=device, max_size_bytes=max_size_bytes) + if self.device.type != "cuda": + raise ValueError( + f"RCCL deterministic collectives require a ROCm device, got {device!r}" + ) + if "nccl" not in self._backend: + raise RuntimeError( + "RCCL deterministic collectives require PyTorch's NCCL process-group API" + ) + + +def create_deterministic_collective( + group: dist.ProcessGroup | None = None, + device: torch.device | str | int | None = None, + *, + max_size_bytes: int = _DEFAULT_MAX_SIZE_BYTES, +) -> Any: + """Create the platform-appropriate deterministic collective. + + CUDA keeps using the existing IPC implementation. ROCm uses RCCL only to + gather rank inputs, followed by the shared local balanced-tree reduction. + The returned object has independent ownership; callers may cache it by + process-group/rank/device and must close an entry before replacing it. + """ + + if getattr(torch.version, "hip", None) is not None: + return RCCLDeterministicCollective( + group=group, + device=device, + max_size_bytes=max_size_bytes, + ) + + # Import lazily to keep the existing CUDA implementation and its extension + # checks independent of the generic transport reference above. + from rl_engine.distributed.collectives import DeterministicCollective + + return DeterministicCollective( + group=group, + device=device, + max_size_bytes=max_size_bytes, + ) + + +__all__ = [ + "RCCLDeterministicCollective", + "TorchDistributedDeterministicCollective", + "create_deterministic_collective", +] diff --git a/tests/distributed/test_transport_deterministic_collective.py b/tests/distributed/test_transport_deterministic_collective.py new file mode 100644 index 00000000..fb6d4dc3 --- /dev/null +++ b/tests/distributed/test_transport_deterministic_collective.py @@ -0,0 +1,329 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 RL-Kernel Contributors + +from __future__ import annotations + +from typing import Any + +import pytest +import torch + +import rl_engine.distributed.collectives as cuda_collectives +import rl_engine.distributed.transport_collectives as transport_collectives +from rl_engine.distributed import ( + RCCLDeterministicCollective, + TorchDistributedDeterministicCollective, +) + + +class _FakeDistributed: + """Single-process model of rank-ordered AllGather transport.""" + + def __init__( + self, + peer_inputs: list[torch.Tensor], + *, + rank: int = 0, + backend: str = "gloo", + peer_signatures: list[tuple[Any, ...]] | None = None, + peer_capacities: list[int] | None = None, + ) -> None: + self.peer_inputs = peer_inputs + self.rank = rank + self.backend = backend + self.peer_signatures = peer_signatures + self.peer_capacities = peer_capacities + self.into_tensor_calls = 0 + self.list_transport_calls = 0 + + @property + def tensor_transport_calls(self) -> int: + return self.into_tensor_calls + self.list_transport_calls + + @staticmethod + def is_available() -> bool: + return True + + @staticmethod + def is_initialized() -> bool: + return True + + def get_rank(self, *, group: Any) -> int: + return self.rank + + def get_world_size(self, *, group: Any) -> int: + return len(self.peer_inputs) + + def get_backend(self, group: Any) -> str: + return self.backend + + def all_gather_object(self, output: list[Any], value: Any, *, group: Any) -> None: + if isinstance(value, int): + values = self.peer_capacities or [value] * len(self.peer_inputs) + else: + values = self.peer_signatures or [value] * len(self.peer_inputs) + output[:] = values + + def all_gather_into_tensor( + self, + output: torch.Tensor, + input: torch.Tensor, + *, + group: Any, + ) -> None: + self.into_tensor_calls += 1 + gathered = torch.cat([peer.reshape(-1) for peer in self.peer_inputs]) + output.copy_(gathered) + + def all_gather( + self, + output: list[torch.Tensor], + input: torch.Tensor, + *, + group: Any, + ) -> None: + self.list_transport_calls += 1 + for destination, peer in zip(output, self.peer_inputs, strict=True): + destination.copy_(peer.reshape(-1)) + + +def _make_collective( + monkeypatch: pytest.MonkeyPatch, + peer_inputs: list[torch.Tensor], + *, + rank: int = 0, + backend: str = "gloo", + peer_signatures: list[tuple[Any, ...]] | None = None, + peer_capacities: list[int] | None = None, + max_size_bytes: int = 1024, +) -> tuple[TorchDistributedDeterministicCollective, _FakeDistributed]: + fake_dist = _FakeDistributed( + peer_inputs, + rank=rank, + backend=backend, + peer_signatures=peer_signatures, + peer_capacities=peer_capacities, + ) + monkeypatch.setattr(transport_collectives, "dist", fake_dist) + collective = TorchDistributedDeterministicCollective( + group=object(), + device="cpu", + max_size_bytes=max_size_bytes, + ) + return collective, fake_dist + + +@pytest.mark.parametrize("world_size", [1, 2, 4, 8]) +@pytest.mark.parametrize("dtype", [torch.float32, torch.float16, torch.bfloat16]) +def test_all_reduce_supports_fixed_world_sizes_and_dtypes( + monkeypatch: pytest.MonkeyPatch, + world_size: int, + dtype: torch.dtype, +) -> None: + peers = [torch.full((2, 3), rank + 1, dtype=dtype) for rank in range(world_size)] + collective, fake_dist = _make_collective(monkeypatch, peers) + + provided = torch.empty_like(peers[0]) + returned = collective.all_reduce(peers[0], out=provided) + + assert returned is provided + assert torch.equal(provided, torch.full_like(provided, world_size * (world_size + 1) // 2)) + assert fake_dist.tensor_transport_calls == (0 if world_size == 1 else 1) + + +def test_all_reduce_uses_balanced_not_rank_ordered_left_fold( + monkeypatch: pytest.MonkeyPatch, +) -> None: + # Balanced: (1e20 + 1) + (-1e20 + 1) == 0 in FP32. + # Left fold: ((1e20 + 1) + -1e20) + 1 == 1 in FP32. + peers = [torch.tensor([value], dtype=torch.float32) for value in (1.0e20, 1.0, -1.0e20, 1.0)] + collective, _ = _make_collective(monkeypatch, peers) + + output = collective.all_reduce(peers[0]) + + assert torch.equal(output, torch.zeros_like(output)) + + +def test_all_reduce_stages_before_writing_in_place(monkeypatch: pytest.MonkeyPatch) -> None: + peers = [torch.full((2, 3), rank + 1, dtype=torch.float32) for rank in range(4)] + collective, _ = _make_collective(monkeypatch, peers) + local = peers[0].clone() + + returned = collective.all_reduce(local, out=local) + + assert returned is local + assert torch.equal(local, torch.full_like(local, 10)) + + +def test_all_gather_is_rank_ordered_and_transport_only( + monkeypatch: pytest.MonkeyPatch, +) -> None: + peers = [torch.arange(rank * 6, (rank + 1) * 6).reshape(2, 3) for rank in range(4)] + collective, fake_dist = _make_collective(monkeypatch, peers, rank=2) + + output = collective.all_gather(peers[2]) + + assert torch.equal(output, torch.cat(peers, dim=0)) + assert fake_dist.tensor_transport_calls == 1 + + +def test_nccl_backend_uses_all_gather_into_tensor_transport( + monkeypatch: pytest.MonkeyPatch, +) -> None: + peers = [torch.full((2, 3), rank) for rank in range(2)] + collective, fake_dist = _make_collective(monkeypatch, peers, backend="nccl") + + output = collective.all_gather(peers[0]) + + assert torch.equal(output, torch.cat(peers, dim=0)) + assert fake_dist.into_tensor_calls == 1 + assert fake_dist.list_transport_calls == 0 + + +def test_reduce_scatter_reduces_then_selects_local_leading_shard( + monkeypatch: pytest.MonkeyPatch, +) -> None: + peers = [torch.full((8, 3), rank + 1, dtype=torch.bfloat16) for rank in range(4)] + collective, _ = _make_collective(monkeypatch, peers, rank=2) + + output = collective.reduce_scatter(peers[2]) + + expected_full = torch.full_like(peers[0], 10) + assert torch.equal(output, expected_full.chunk(4, dim=0)[2]) + + +def test_matching_signature_is_checked_before_tensor_transport( + monkeypatch: pytest.MonkeyPatch, +) -> None: + peers = [torch.ones(2, 3), torch.ones(2, 3)] + signatures = [ + ("all_reduce", (2, 3), "torch.float32", 6), + ("reduce_scatter", (2, 3), "torch.float32", 6), + ] + collective, fake_dist = _make_collective( + monkeypatch, + peers, + peer_signatures=signatures, + ) + + with pytest.raises(ValueError, match="matching shapes and dtypes"): + collective.all_reduce(peers[0]) + assert fake_dist.tensor_transport_calls == 0 + + +def test_capacity_must_match_on_every_rank(monkeypatch: pytest.MonkeyPatch) -> None: + peers = [torch.ones(2, 3), torch.ones(2, 3)] + + with pytest.raises(ValueError, match="same max_size_bytes"): + _make_collective( + monkeypatch, + peers, + max_size_bytes=1024, + peer_capacities=[1024, 2048], + ) + + +def test_validation_fails_closed_before_transport(monkeypatch: pytest.MonkeyPatch) -> None: + peers = [torch.ones(4, 2), torch.ones(4, 2)] + collective, fake_dist = _make_collective(monkeypatch, peers, max_size_bytes=31) + + with pytest.raises(TypeError, match="float32, float16, and bfloat16"): + collective.all_reduce(torch.ones(1, dtype=torch.int32)) + with pytest.raises(ValueError, match="max_size_bytes"): + collective.all_reduce(peers[0]) + with pytest.raises(ValueError, match=r"input.size\(0\).+divisible"): + collective.reduce_scatter(torch.ones(3, 2)) + with pytest.raises(ValueError, match="at least one dimension"): + collective.all_gather(torch.tensor(1.0)) + assert fake_dist.tensor_transport_calls == 0 + + +def test_lifecycle_is_idempotent_and_context_manager_closes( + monkeypatch: pytest.MonkeyPatch, +) -> None: + peers = [torch.ones(2, 3)] + collective, _ = _make_collective(monkeypatch, peers) + + with collective as entered: + assert entered is collective + assert not collective.closed + assert torch.equal(collective.all_reduce(peers[0]), peers[0]) + + assert collective.closed + collective.close() + with pytest.raises(RuntimeError, match="closed"): + collective.all_reduce(peers[0]) + + +@pytest.mark.parametrize("world_size", [3, 16]) +def test_unsupported_world_size_is_rejected( + monkeypatch: pytest.MonkeyPatch, + world_size: int, +) -> None: + fake_dist = _FakeDistributed([torch.ones(1)] * world_size) + monkeypatch.setattr(transport_collectives, "dist", fake_dist) + + with pytest.raises(ValueError, match="world_size in"): + TorchDistributedDeterministicCollective(group=object(), device="cpu") + + +def test_rccl_class_requires_rocm_build(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setattr(transport_collectives.torch.version, "hip", None, raising=False) + + with pytest.raises(RuntimeError, match="ROCm PyTorch build"): + RCCLDeterministicCollective(group=object(), device="cuda:0") + + +def test_rccl_class_requires_nccl_process_group(monkeypatch: pytest.MonkeyPatch) -> None: + fake_dist = _FakeDistributed([torch.ones(1)], backend="gloo") + monkeypatch.setattr(transport_collectives, "dist", fake_dist) + monkeypatch.setattr(transport_collectives.torch.version, "hip", "6.3", raising=False) + monkeypatch.setattr(transport_collectives.torch.cuda, "is_available", lambda: True) + monkeypatch.setattr(transport_collectives.torch.cuda, "current_device", lambda: 0) + + with pytest.raises(RuntimeError, match="NCCL process-group API"): + RCCLDeterministicCollective(group=object(), device="cuda:0") + + +def test_factory_dispatches_rocm_to_rccl(monkeypatch: pytest.MonkeyPatch) -> None: + sentinel = object() + calls: list[dict[str, Any]] = [] + + def fake_rccl(**kwargs: Any) -> object: + calls.append(kwargs) + return sentinel + + monkeypatch.setattr(transport_collectives.torch.version, "hip", "6.3", raising=False) + monkeypatch.setattr(transport_collectives, "RCCLDeterministicCollective", fake_rccl) + + group = object() + result = transport_collectives.create_deterministic_collective( + group=group, + device="cuda:3", + max_size_bytes=1234, + ) + + assert result is sentinel + assert calls == [{"group": group, "device": "cuda:3", "max_size_bytes": 1234}] + + +def test_factory_preserves_existing_cuda_collective(monkeypatch: pytest.MonkeyPatch) -> None: + sentinel = object() + calls: list[dict[str, Any]] = [] + + def fake_cuda(**kwargs: Any) -> object: + calls.append(kwargs) + return sentinel + + monkeypatch.setattr(transport_collectives.torch.version, "hip", None, raising=False) + monkeypatch.setattr(cuda_collectives, "DeterministicCollective", fake_cuda) + + group = object() + result = transport_collectives.create_deterministic_collective( + group=group, + device="cuda:1", + max_size_bytes=4321, + ) + + assert result is sentinel + assert calls == [{"group": group, "device": "cuda:1", "max_size_bytes": 4321}] From 6ad03cab5aeca9463b2f6539eb882d54a7512762 Mon Sep 17 00:00:00 2001 From: frank-2077 Date: Thu, 20 Aug 2026 14:26:31 +0000 Subject: [PATCH 03/28] feat(ffn): add deterministic Qwen3 FFN assembly --- rl_engine/kernels/ops/pytorch/ffn/__init__.py | 14 + rl_engine/kernels/ops/pytorch/ffn/ffn.py | 371 ++++++++++++++++++ 2 files changed, 385 insertions(+) create mode 100644 rl_engine/kernels/ops/pytorch/ffn/__init__.py create mode 100644 rl_engine/kernels/ops/pytorch/ffn/ffn.py diff --git a/rl_engine/kernels/ops/pytorch/ffn/__init__.py b/rl_engine/kernels/ops/pytorch/ffn/__init__.py new file mode 100644 index 00000000..10cd0c36 --- /dev/null +++ b/rl_engine/kernels/ops/pytorch/ffn/__init__.py @@ -0,0 +1,14 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 RL-Kernel Contributors + +from .ffn import ( + QWEN3_8B_HIDDEN_SIZE, + QWEN3_8B_INTERMEDIATE_SIZE, + qwen3_ffn, +) + +__all__ = [ + "QWEN3_8B_HIDDEN_SIZE", + "QWEN3_8B_INTERMEDIATE_SIZE", + "qwen3_ffn", +] diff --git a/rl_engine/kernels/ops/pytorch/ffn/ffn.py b/rl_engine/kernels/ops/pytorch/ffn/ffn.py new file mode 100644 index 00000000..e5ce71c4 --- /dev/null +++ b/rl_engine/kernels/ops/pytorch/ffn/ffn.py @@ -0,0 +1,371 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 RL-Kernel Contributors +"""Bias-free gated FFN assembled from deterministic GPU kernels. + +The numerical contract intentionally follows PR #321: GEMM and SwiGLU each +consume and produce BF16 tensors. This module does not keep the whole FFN in +FP32 and downcast only its final result. +""" + +from __future__ import annotations + +from typing import Any + +import torch +from torch import Tensor + +from rl_engine.kernels.ops.base import _C, _EXT_AVAILABLE + +QWEN3_8B_HIDDEN_SIZE = 4096 +QWEN3_8B_INTERMEDIATE_SIZE = 12288 + +_REQUIRED_SYMBOLS = ( + "det_gemm_fwd", + "det_gemm_db", + "swiglu_forward", + "swiglu_backward", +) +_COLLECTIVE_MIN_CAPACITY_BYTES = 64 * 1024 * 1024 +_COLLECTIVES: dict[tuple[int, int, int, int], Any] = {} + + +def _require_ffn_kernels() -> None: + missing = [name for name in _REQUIRED_SYMBOLS if not hasattr(_C, name)] + if not _EXT_AVAILABLE or _C is None or missing: + suffix = f" Missing symbols: {', '.join(missing)}." if missing else "" + raise RuntimeError( + f"qwen3_ffn requires the compiled deterministic GEMM and SwiGLU GPU kernels.{suffix}" + ) + + +def _require_parallel_group(group: Any, name: str): + if group is None: + return None + + import torch.distributed as dist + + if not dist.is_available(): + raise RuntimeError(f"{name}-parallel FFN requires torch.distributed.") + if not dist.is_initialized(): + raise RuntimeError(f"{name}-parallel FFN requires an initialized process group.") + if dist.get_world_size(group=group) <= 1: + raise ValueError(f"{name}_group must contain at least two ranks.") + return dist + + +def _validate_ffn_inputs( + rmsnorm_output: Tensor, + gate_weight: Tensor, + up_weight: Tensor, + down_weight: Tensor, +) -> None: + tensors = { + "rmsnorm_output": rmsnorm_output, + "gate_weight": gate_weight, + "up_weight": up_weight, + "down_weight": down_weight, + } + for name, tensor in tensors.items(): + if not isinstance(tensor, Tensor): + raise TypeError(f"{name} must be a torch.Tensor, got {type(tensor)!r}.") + + if rmsnorm_output.dim() < 1: + raise ValueError("rmsnorm_output must have at least one dimension.") + if rmsnorm_output.numel() == 0: + raise ValueError("rmsnorm_output must contain at least one token.") + for name, weight in ( + ("gate_weight", gate_weight), + ("up_weight", up_weight), + ("down_weight", down_weight), + ): + if weight.dim() != 2: + raise ValueError(f"{name} must be 2-D, got shape {tuple(weight.shape)}.") + + hidden_size = rmsnorm_output.size(-1) + intermediate_size = gate_weight.size(0) + if intermediate_size == 0: + raise ValueError("FFN intermediate size must be positive.") + expected_shapes = { + "gate_weight": (intermediate_size, hidden_size), + "up_weight": (intermediate_size, hidden_size), + "down_weight": (hidden_size, intermediate_size), + } + for name, expected in expected_shapes.items(): + actual = tuple(tensors[name].shape) + if actual != expected: + raise ValueError(f"{name} must have shape {expected}, got {actual}.") + + # Validate dtype for every input before device placement so callers get + # the most actionable contract error even on CPU-only build hosts. + for name, tensor in tensors.items(): + if tensor.dtype != torch.bfloat16: + raise TypeError(f"{name} must have dtype bfloat16, got {tensor.dtype}.") + + for name, tensor in tensors.items(): + # PyTorch exposes both NVIDIA CUDA and AMD ROCm devices through the + # ``cuda`` device API, so ``is_cuda`` is correct for both backends. + if not tensor.is_cuda: + raise RuntimeError(f"{name} must be on a CUDA/ROCm GPU device, got '{tensor.device}'.") + if tensor.device != rmsnorm_output.device: + raise RuntimeError( + f"all FFN inputs must be on {rmsnorm_output.device}, got {name} on {tensor.device}." + ) + + +def _create_collective(*, group: Any, max_size_bytes: int): + """Create the platform collective lazily, keeping single-GPU independent. + + This small boundary is intentionally easy to inject in unit tests. The + distributed factory selects CUDA IPC on NVIDIA and RCCL transport with a + deterministic local reduction tree on ROCm. + """ + + try: + from rl_engine.distributed import create_deterministic_collective + except ImportError as exc: + raise RuntimeError( + "parallel qwen3_ffn requires the platform deterministic collective " + "factory; single-device qwen3_ffn remains available" + ) from exc + + return create_deterministic_collective( + group=group, + max_size_bytes=max_size_bytes, + ) + + +def _collective_for_group(group: Any, *, min_size_bytes: int): + if group is None: + return None + + import torch.distributed as dist + + rank = dist.get_rank(group=group) + world_size = dist.get_world_size(group=group) + device_index = torch.cuda.current_device() + key = (id(group), rank, world_size, device_index) + cached = _COLLECTIVES.get(key) + if cached is not None and cached.max_size_bytes >= min_size_bytes: + return cached + if cached is not None: + cached.close() + + collective = _create_collective( + group=group, + max_size_bytes=max(_COLLECTIVE_MIN_CAPACITY_BYTES, min_size_bytes), + ) + _COLLECTIVES[key] = collective + return collective + + +def _all_gather_tokens(tensor: Tensor, collective: Any) -> Tensor: + return collective.all_gather(tensor.contiguous()) + + +def _reduce_scatter_tokens(tensor: Tensor, collective: Any) -> Tensor: + world_size = collective.world_size + if tensor.size(0) % world_size != 0: + raise ValueError( + "the gathered token count must be divisible by the tensor-parallel " + f"world size, got {tensor.size(0)} and {world_size}." + ) + return collective.reduce_scatter(tensor.contiguous()) + + +def _all_reduce_inplace(tensor: Tensor, collective: Any) -> Tensor: + return collective.all_reduce(tensor, out=tensor) + + +class _DeterministicFFNFunction(torch.autograd.Function): + @staticmethod + def forward( + ctx, + rmsnorm_output: Tensor, + gate_weight: Tensor, + up_weight: Tensor, + down_weight: Tensor, + tp_group: Any, + cp_group: Any, + sequence_parallel: bool, + ) -> Tensor: + tp_dist = _require_parallel_group(tp_group, "tensor") + _require_parallel_group(cp_group, "context") + if sequence_parallel and tp_dist is None: + raise ValueError("sequence_parallel requires a tensor-parallel group.") + + input_shape = rmsnorm_output.shape + rmsnorm_output_2d = rmsnorm_output.reshape(-1, input_shape[-1]).contiguous() + tp_world = tp_dist.get_world_size(group=tp_group) if tp_dist is not None else 1 + gemm_tokens = rmsnorm_output_2d.size(0) * (tp_world if sequence_parallel else 1) + element_size = rmsnorm_output_2d.element_size() + min_size_bytes = max( + gemm_tokens * rmsnorm_output_2d.size(1) * element_size, + gemm_tokens * gate_weight.size(0) * element_size, + gate_weight.numel() * element_size, + up_weight.numel() * element_size, + down_weight.numel() * element_size, + ) + # Create TP before CP so every rank follows the same group order. + tp_collective = _collective_for_group(tp_group, min_size_bytes=min_size_bytes) + cp_collective = _collective_for_group(cp_group, min_size_bytes=min_size_bytes) + + if sequence_parallel: + rmsnorm_output_2d = _all_gather_tokens(rmsnorm_output_2d, tp_collective) + + # Model weights use HuggingFace's [out, in] layout; GEMM consumes [K, N]. + # Each native call returns BF16 before the next stage, matching PR #321. + gate = _C.det_gemm_fwd(rmsnorm_output_2d, gate_weight.t().contiguous()) + up = _C.det_gemm_fwd(rmsnorm_output_2d, up_weight.t().contiguous()) + activated = _C.swiglu_forward(gate, up) + output = _C.det_gemm_fwd(activated, down_weight.t().contiguous()) + + if sequence_parallel: + output = _reduce_scatter_tokens(output, tp_collective) + elif tp_collective is not None: + output = _all_reduce_inplace(output, tp_collective) + + ctx.save_for_backward( + rmsnorm_output_2d, + gate, + up, + activated, + gate_weight, + up_weight, + down_weight, + ) + ctx.input_shape = input_shape + ctx.tp_collective = tp_collective + ctx.cp_collective = cp_collective + ctx.sequence_parallel = sequence_parallel + return output.reshape(*input_shape[:-1], output.size(-1)) + + @staticmethod + def backward(ctx, grad_output: Tensor): + ( + rmsnorm_output, + gate, + up, + activated, + gate_weight, + up_weight, + down_weight, + ) = ctx.saved_tensors + tp_collective = ctx.tp_collective + cp_collective = ctx.cp_collective + grad_output = grad_output.reshape(-1, grad_output.size(-1)).contiguous() + if ctx.sequence_parallel: + grad_output = _all_gather_tokens(grad_output, tp_collective) + + # Down weight gradients must see every CP token so det_gemm_db's + # reduction tree matches CP=1. Local dW plus AllReduce would use a + # different parenthesization at many token counts. + if cp_collective is not None: + activated_full = _all_gather_tokens(activated, cp_collective) + grad_output_full = _all_gather_tokens(grad_output, cp_collective) + grad_down_weight = _C.det_gemm_db(activated_full, grad_output_full).t().contiguous() + else: + grad_down_weight = _C.det_gemm_db(activated, grad_output).t().contiguous() + + # Down input-gradient shards concatenate across TP; no TP reduction. + grad_activated = _C.det_gemm_fwd(grad_output, down_weight) + grad_gate, grad_up = _C.swiglu_backward(grad_activated, gate, up) + + if cp_collective is not None: + rmsnorm_full = _all_gather_tokens(rmsnorm_output, cp_collective) + grad_gate_full = _all_gather_tokens(grad_gate, cp_collective) + grad_up_full = _all_gather_tokens(grad_up, cp_collective) + grad_gate_weight = _C.det_gemm_db(rmsnorm_full, grad_gate_full).t().contiguous() + grad_up_weight = _C.det_gemm_db(rmsnorm_full, grad_up_full).t().contiguous() + else: + grad_gate_weight = _C.det_gemm_db(rmsnorm_output, grad_gate).t().contiguous() + grad_up_weight = _C.det_gemm_db(rmsnorm_output, grad_up).t().contiguous() + + # Gate/Up input gradients reduce across TP, then add locally. + grad_rmsnorm_from_gate = _C.det_gemm_fwd(grad_gate, gate_weight) + if ctx.sequence_parallel: + grad_rmsnorm_from_gate = _reduce_scatter_tokens( + grad_rmsnorm_from_gate, + tp_collective, + ) + elif tp_collective is not None: + grad_rmsnorm_from_gate = _all_reduce_inplace( + grad_rmsnorm_from_gate, + tp_collective, + ) + + grad_rmsnorm_from_up = _C.det_gemm_fwd(grad_up, up_weight) + if ctx.sequence_parallel: + grad_rmsnorm_from_up = _reduce_scatter_tokens( + grad_rmsnorm_from_up, + tp_collective, + ) + elif tp_collective is not None: + grad_rmsnorm_from_up = _all_reduce_inplace( + grad_rmsnorm_from_up, + tp_collective, + ) + + grad_rmsnorm_output = grad_rmsnorm_from_gate.add_(grad_rmsnorm_from_up) + return ( + grad_rmsnorm_output.reshape(ctx.input_shape), + grad_gate_weight, + grad_up_weight, + grad_down_weight, + None, + None, + None, + ) + + +def qwen3_ffn( + rmsnorm_output: Tensor, + gate_weight: Tensor, + up_weight: Tensor, + down_weight: Tensor, + *, + tp_group: Any = None, + cp_group: Any = None, + sequence_parallel: bool = False, +) -> Tensor: + """Apply a bias-free SiLU-gated FFN with deterministic backward kernels. + + Args: + rmsnorm_output: RMSNorm output, shape ``[..., H]``. + gate_weight: Gate projection in HuggingFace ``[out, in]`` layout, + shape ``[I_local, H]``. + up_weight: Up projection in HuggingFace ``[out, in]`` layout, shape + ``[I_local, H]``. + down_weight: Down projection in HuggingFace ``[out, in]`` layout, + shape ``[H, I_local]``. + tp_group: Optional tensor-parallel process group. Gate and Up are + column-parallel; Down is row-parallel. The platform factory uses + deterministic fixed-tree collectives instead of backend reduction + arithmetic. Projection shards must be equal contiguous + intermediate-dimension ranges in process-group rank order. For + TP=1-equivalent bit patterns, every local range must be a complete + subtree of the canonical GEMM reduction tree. + cp_group: Optional context-parallel process group. Each rank owns + different token rows and the same local weight shards. Backward + AllGathers CP tokens before running full-token ``det_gemm_db`` so + weight gradients match CP=1 bitwise. Token shards must be equal + contiguous flattened-token ranges in process-group rank order. + sequence_parallel: Whether ``rmsnorm_output`` and the returned output + are equal rank-ordered shards of the flattened token dimension + across ``tp_group``. + + Returns: + FFN output with shape ``[..., H]`` and dtype ``torch.bfloat16``. + """ + _validate_ffn_inputs(rmsnorm_output, gate_weight, up_weight, down_weight) + _require_ffn_kernels() + if not isinstance(sequence_parallel, bool): + raise TypeError("sequence_parallel must be a bool.") + return _DeterministicFFNFunction.apply( + rmsnorm_output, + gate_weight, + up_weight, + down_weight, + tp_group, + cp_group, + sequence_parallel, + ) From f7dc7a9a5dadde6a0d7bacdd33b1fcc57cb8a8f3 Mon Sep 17 00:00:00 2001 From: frank-2077 Date: Thu, 20 Aug 2026 14:26:38 +0000 Subject: [PATCH 04/28] test(ffn): cover staged BF16 FFN contract --- tests/test_qwen_ffn.py | 364 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 364 insertions(+) create mode 100644 tests/test_qwen_ffn.py diff --git a/tests/test_qwen_ffn.py b/tests/test_qwen_ffn.py new file mode 100644 index 00000000..e0c4a18f --- /dev/null +++ b/tests/test_qwen_ffn.py @@ -0,0 +1,364 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 RL-Kernel Contributors +"""First-stage tests for the CUDA/ROCm deterministic Qwen3 FFN. + +The CPU tests replace the native extension with a small PyTorch stub. This +keeps the public API, HuggingFace weight layout, autograd wiring, and BF16 +stage-boundary contract testable on build hosts without a GPU. GPU checks are +single-device only; distributed topology equivalence belongs to the later +collective acceptance phase. +""" + +from __future__ import annotations + +import inspect + +import pytest +import torch +import torch.nn.functional as F + +import rl_engine.kernels.ops.pytorch.ffn.ffn as ffn_module +from rl_engine.kernels.ops.base import _C, _EXT_AVAILABLE +from rl_engine.kernels.ops.pytorch.ffn import qwen3_ffn as public_qwen3_ffn +from rl_engine.kernels.ops.pytorch.ffn.ffn import ( + QWEN3_8B_HIDDEN_SIZE, + QWEN3_8B_INTERMEDIATE_SIZE, + qwen3_ffn, +) +from rl_engine.platforms.device import device_ctx + +_REQUIRED_SYMBOLS = ( + "det_gemm_fwd", + "det_gemm_db", + "swiglu_forward", + "swiglu_backward", +) +_IS_ROCM = getattr(torch.version, "hip", None) is not None +_IS_GPU = torch.cuda.is_available() and device_ctx.device.type == "cuda" +_HAS_GPU_FFN = ( + _IS_GPU + and _EXT_AVAILABLE + and _C is not None + and all(hasattr(_C, name) for name in _REQUIRED_SYMBOLS) +) +_GPU_NAME = "ROCm" if _IS_ROCM else "CUDA" + +requires_gpu_ffn = pytest.mark.skipif( + not _HAS_GPU_FFN, + reason=f"{_GPU_NAME} FFN requires a GPU and the GEMM/SwiGLU extension symbols", +) + + +def _randn(shape, *, seed: int, dtype=torch.float32, device="cpu"): + generator = torch.Generator(device="cpu").manual_seed(seed) + value = torch.randn(*shape, generator=generator, dtype=torch.float32) * 0.1 + return value.to(device=device, dtype=dtype) + + +def _reference(hidden_states, gate_weight, up_weight, down_weight): + gate = hidden_states @ gate_weight.t() + up = hidden_states @ up_weight.t() + return (F.silu(gate) * up) @ down_weight.t() + + +class _TorchKernelStub: + """Extension-shaped FP32 stub used to check custom autograd algebra.""" + + def __init__(self) -> None: + self.calls: list[str] = [] + + def det_gemm_fwd(self, a, b): + self.calls.append("det_gemm_fwd") + return a @ b + + def det_gemm_db(self, a, grad_output): + self.calls.append("det_gemm_db") + return a.t().contiguous() @ grad_output + + def swiglu_forward(self, gate, up): + self.calls.append("swiglu_forward") + return F.silu(gate) * up + + def swiglu_backward(self, grad_output, gate, up): + self.calls.append("swiglu_backward") + sigmoid = torch.sigmoid(gate) + grad_gate = grad_output * up * sigmoid * (1.0 + gate * (1.0 - sigmoid)) + grad_up = grad_output * F.silu(gate) + return grad_gate, grad_up + + +class _BF16BoundaryStub(_TorchKernelStub): + """Model native ops that accumulate in FP32 and write BF16 per stage.""" + + def __init__(self) -> None: + super().__init__() + self.input_dtypes: list[tuple[str, tuple[torch.dtype, ...]]] = [] + + def _record(self, name, *values) -> None: + self.calls.append(name) + self.input_dtypes.append((name, tuple(value.dtype for value in values))) + + def det_gemm_fwd(self, a, b): + self._record("det_gemm_fwd", a, b) + return (a.float() @ b.float()).to(torch.bfloat16) + + def det_gemm_db(self, a, grad_output): + self._record("det_gemm_db", a, grad_output) + return (a.float().t().contiguous() @ grad_output.float()).to(torch.bfloat16) + + def swiglu_forward(self, gate, up): + self._record("swiglu_forward", gate, up) + return (F.silu(gate.float()) * up.float()).to(torch.bfloat16) + + def swiglu_backward(self, grad_output, gate, up): + self._record("swiglu_backward", grad_output, gate, up) + gate_fp32 = gate.float() + sigmoid = torch.sigmoid(gate_fp32) + grad_gate = grad_output.float() * up.float() * sigmoid * (1.0 + gate_fp32 * (1.0 - sigmoid)) + grad_up = grad_output.float() * F.silu(gate_fp32) + return grad_gate.to(torch.bfloat16), grad_up.to(torch.bfloat16) + + +class _ValidationTensor: + """Tensor-shaped object for device-independent validation-order tests.""" + + def __init__(self, shape, dtype=torch.bfloat16) -> None: + self.shape = torch.Size(shape) + self.dtype = dtype + self.device = torch.device("cuda") + self.is_cuda = True + + def dim(self): + return len(self.shape) + + def numel(self): + result = 1 + for size in self.shape: + result *= size + return result + + def size(self, dim): + return self.shape[dim] + + +def _install_stub(monkeypatch, stub) -> None: + monkeypatch.setattr(ffn_module, "_C", stub) + monkeypatch.setattr(ffn_module, "_EXT_AVAILABLE", True) + # Native input validation intentionally requires GPU tensors. Stub tests + # exercise the public function on CPU after validation itself is tested. + monkeypatch.setattr(ffn_module, "_validate_ffn_inputs", lambda *args: None) + + +def test_qwen3_ffn_public_api_and_model_dimensions_are_pinned(): + assert public_qwen3_ffn is qwen3_ffn + assert QWEN3_8B_HIDDEN_SIZE == 4096 + assert QWEN3_8B_INTERMEDIATE_SIZE == 12288 + + signature = inspect.signature(qwen3_ffn) + assert tuple(signature.parameters) == ( + "rmsnorm_output", + "gate_weight", + "up_weight", + "down_weight", + "tp_group", + "cp_group", + "sequence_parallel", + ) + assert signature.parameters["tp_group"].kind is inspect.Parameter.KEYWORD_ONLY + assert signature.parameters["cp_group"].kind is inspect.Parameter.KEYWORD_ONLY + assert signature.parameters["sequence_parallel"].default is False + + +def test_qwen3_ffn_stub_shape_layout_and_backward_match_autograd(monkeypatch): + stub = _TorchKernelStub() + _install_stub(monkeypatch, stub) + + hidden = _randn((2, 3, 8), seed=0) + gate_weight = _randn((12, 8), seed=1) + up_weight = _randn((12, 8), seed=2) + down_weight = _randn((8, 12), seed=3) + grad_output = _randn(hidden.shape, seed=4) + + reference_inputs = [ + value.detach().clone().requires_grad_(True) + for value in (hidden, gate_weight, up_weight, down_weight) + ] + expected = _reference(*reference_inputs) + expected.backward(grad_output) + + actual_inputs = [ + value.detach().clone().requires_grad_(True) + for value in (hidden, gate_weight, up_weight, down_weight) + ] + actual = qwen3_ffn(*actual_inputs) + actual.backward(grad_output) + + assert actual.shape == hidden.shape + torch.testing.assert_close(actual, expected.detach()) + for actual_input, reference_input in zip(actual_inputs, reference_inputs, strict=True): + torch.testing.assert_close(actual_input.grad, reference_input.grad) + + assert stub.calls.count("det_gemm_fwd") == 6 + assert stub.calls.count("det_gemm_db") == 3 + assert stub.calls.count("swiglu_forward") == 1 + assert stub.calls.count("swiglu_backward") == 1 + + +def test_qwen3_ffn_preserves_bf16_at_every_native_stage(monkeypatch): + stub = _BF16BoundaryStub() + _install_stub(monkeypatch, stub) + + hidden = _randn((2, 3, 8), seed=10, dtype=torch.bfloat16).requires_grad_(True) + gate_weight = _randn((12, 8), seed=11, dtype=torch.bfloat16).requires_grad_(True) + up_weight = _randn((12, 8), seed=12, dtype=torch.bfloat16).requires_grad_(True) + down_weight = _randn((8, 12), seed=13, dtype=torch.bfloat16).requires_grad_(True) + grad_output = _randn(hidden.shape, seed=14, dtype=torch.bfloat16) + + actual = qwen3_ffn(hidden, gate_weight, up_weight, down_weight) + actual.backward(grad_output) + + gate = (hidden.detach().float() @ gate_weight.detach().float().t()).to(torch.bfloat16) + up = (hidden.detach().float() @ up_weight.detach().float().t()).to(torch.bfloat16) + activated = (F.silu(gate.float()) * up.float()).to(torch.bfloat16) + expected = (activated.float() @ down_weight.detach().float().t()).to(torch.bfloat16) + + assert actual.dtype is torch.bfloat16 + assert torch.equal(actual.detach(), expected) + assert all( + dtype is torch.bfloat16 for _, input_dtypes in stub.input_dtypes for dtype in input_dtypes + ) + for tensor in (hidden, gate_weight, up_weight, down_weight): + assert tensor.grad is not None + assert tensor.grad.dtype is torch.bfloat16 + + +@pytest.mark.parametrize("weight_name", ["gate_weight", "up_weight", "down_weight"]) +def test_qwen3_ffn_rejects_non_huggingface_weight_layout(weight_name): + tensors = { + "rmsnorm_output": torch.empty((2, 8), dtype=torch.bfloat16), + "gate_weight": torch.empty((12, 8), dtype=torch.bfloat16), + "up_weight": torch.empty((12, 8), dtype=torch.bfloat16), + "down_weight": torch.empty((8, 12), dtype=torch.bfloat16), + } + tensors[weight_name] = tensors[weight_name].t().contiguous() + + with pytest.raises(ValueError, match=rf"{weight_name} must have shape"): + qwen3_ffn(**tensors) + + +def test_qwen3_ffn_rejects_zero_intermediate_size_before_device_dispatch(): + tensors = { + "rmsnorm_output": torch.empty((2, 8), dtype=torch.bfloat16), + "gate_weight": torch.empty((0, 8), dtype=torch.bfloat16), + "up_weight": torch.empty((0, 8), dtype=torch.bfloat16), + "down_weight": torch.empty((8, 0), dtype=torch.bfloat16), + } + + with pytest.raises(ValueError, match="intermediate size must be positive"): + qwen3_ffn(**tensors) + + +@pytest.mark.parametrize( + "input_name", + ("rmsnorm_output", "gate_weight", "up_weight", "down_weight"), +) +def test_qwen3_ffn_rejects_non_bf16_inputs_before_device_dispatch(input_name, monkeypatch): + monkeypatch.setattr(ffn_module, "Tensor", _ValidationTensor) + tensors = { + "rmsnorm_output": _ValidationTensor((2, 8)), + "gate_weight": _ValidationTensor((12, 8)), + "up_weight": _ValidationTensor((12, 8)), + "down_weight": _ValidationTensor((8, 12)), + } + tensors[input_name].dtype = torch.float32 + + with pytest.raises(TypeError, match=rf"{input_name} must have dtype bfloat16"): + ffn_module._validate_ffn_inputs(**tensors) + + +def test_qwen3_ffn_sequence_parallel_flag_must_be_bool(monkeypatch): + _install_stub(monkeypatch, _TorchKernelStub()) + tensors = ( + torch.empty((2, 8)), + torch.empty((12, 8)), + torch.empty((12, 8)), + torch.empty((8, 12)), + ) + + with pytest.raises(TypeError, match="sequence_parallel must be a bool"): + qwen3_ffn(*tensors, sequence_parallel=1) + + +@requires_gpu_ffn +def test_qwen3_ffn_gpu_forward_backward_matches_fp32_reference(): + device = device_ctx.device + hidden = _randn((2, 3, 32), seed=20, dtype=torch.bfloat16, device=device) + gate_weight = _randn((64, 32), seed=21, dtype=torch.bfloat16, device=device) + up_weight = _randn((64, 32), seed=22, dtype=torch.bfloat16, device=device) + down_weight = _randn((32, 64), seed=23, dtype=torch.bfloat16, device=device) + grad_output = _randn(hidden.shape, seed=24, dtype=torch.bfloat16, device=device) + + reference_inputs = [ + value.detach().cpu().float().requires_grad_(True) + for value in (hidden, gate_weight, up_weight, down_weight) + ] + expected = _reference(*reference_inputs) + expected.backward(grad_output.cpu().float()) + + actual_inputs = [ + value.detach().clone().requires_grad_(True) + for value in (hidden, gate_weight, up_weight, down_weight) + ] + actual = qwen3_ffn(*actual_inputs) + actual.backward(grad_output) + + assert actual.shape == hidden.shape + assert actual.dtype is torch.bfloat16 + torch.testing.assert_close(actual.cpu().float(), expected.detach(), atol=5e-2, rtol=2e-2) + for actual_input, reference_input in zip(actual_inputs, reference_inputs, strict=True): + assert actual_input.grad.dtype is torch.bfloat16 + torch.testing.assert_close( + actual_input.grad.cpu().float(), + reference_input.grad, + atol=5e-2, + rtol=2e-2, + ) + + +@requires_gpu_ffn +def test_qwen3_ffn_gpu_repeat_is_bitwise_and_train_infer_match(): + device = device_ctx.device + hidden = _randn((8, 32), seed=30, dtype=torch.bfloat16, device=device) + gate_weight = _randn((64, 32), seed=31, dtype=torch.bfloat16, device=device) + up_weight = _randn((64, 32), seed=32, dtype=torch.bfloat16, device=device) + down_weight = _randn((32, 64), seed=33, dtype=torch.bfloat16, device=device) + + with torch.no_grad(): + first = qwen3_ffn(hidden, gate_weight, up_weight, down_weight) + second = qwen3_ffn(hidden, gate_weight, up_weight, down_weight) + train_hidden = hidden.detach().clone().requires_grad_(True) + train = qwen3_ffn(train_hidden, gate_weight, up_weight, down_weight) + + assert torch.equal(first, second) + assert torch.equal(first, train.detach()) + + +@requires_gpu_ffn +def test_qwen3_ffn_gpu_output_and_hidden_gradient_are_token_slice_invariant(): + device = device_ctx.device + hidden = _randn((6, 32), seed=40, dtype=torch.bfloat16, device=device) + gate_weight = _randn((64, 32), seed=41, dtype=torch.bfloat16, device=device) + up_weight = _randn((64, 32), seed=42, dtype=torch.bfloat16, device=device) + down_weight = _randn((32, 64), seed=43, dtype=torch.bfloat16, device=device) + grad_output = _randn(hidden.shape, seed=44, dtype=torch.bfloat16, device=device) + + full_hidden = hidden.detach().clone().requires_grad_(True) + full_output = qwen3_ffn(full_hidden, gate_weight, up_weight, down_weight) + full_output.backward(grad_output) + + slice_hidden = hidden[2:4].detach().clone().requires_grad_(True) + slice_output = qwen3_ffn(slice_hidden, gate_weight, up_weight, down_weight) + slice_output.backward(grad_output[2:4]) + + assert torch.equal(slice_output, full_output[2:4]) + assert torch.equal(slice_hidden.grad, full_hidden.grad[2:4]) From 49fa1c53f0f6c36fbed1b5e48f0f2ef9f9a747f7 Mon Sep 17 00:00:00 2001 From: frank-2077 Date: Thu, 20 Aug 2026 14:28:49 +0000 Subject: [PATCH 05/28] test(ffn): cover TP CP and SP topologies --- tests/distributed/test_qwen_ffn_topology.py | 511 ++++++++++++++++++++ 1 file changed, 511 insertions(+) create mode 100644 tests/distributed/test_qwen_ffn_topology.py diff --git a/tests/distributed/test_qwen_ffn_topology.py b/tests/distributed/test_qwen_ffn_topology.py new file mode 100644 index 00000000..c68afb9e --- /dev/null +++ b/tests/distributed/test_qwen_ffn_topology.py @@ -0,0 +1,511 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 RL-Kernel Contributors +"""Real multi-GPU topology checks for the deterministic Qwen3 FFN. + +PyTorch exposes both NCCL on NVIDIA and RCCL on AMD through the ``nccl`` +process-group backend. The FFN's platform factory then selects CUDA IPC or +RCCL AllGather transport without any test-side backend branching. +""" + +from __future__ import annotations + +import os +import queue +import tempfile +import traceback +from datetime import timedelta +from pathlib import Path +from typing import Any + +import pytest +import torch +import torch.multiprocessing as mp + +import rl_engine.kernels.ops.pytorch.ffn.ffn as ffn_module +from rl_engine.kernels.ops.base import _C, _EXT_AVAILABLE +from rl_engine.kernels.ops.pytorch.ffn.ffn import ( + QWEN3_8B_HIDDEN_SIZE, + QWEN3_8B_INTERMEDIATE_SIZE, + qwen3_ffn, +) + +_REQUIRED_FFN_SYMBOLS = ( + "det_gemm_fwd", + "det_gemm_db", + "swiglu_forward", + "swiglu_backward", +) +_REQUIRED_CUDA_COLLECTIVE_SYMBOLS = ( + "deterministic_collective_ipc_meta", + "deterministic_collective_create", + "deterministic_collective_destroy", + "deterministic_collective_stage", + "deterministic_collective_all_reduce", + "deterministic_collective_reduce_scatter", + "deterministic_collective_all_gather", +) +_IS_ROCM = getattr(torch.version, "hip", None) is not None +_EXTERNAL_WORLD_SIZE = int(os.environ.get("WORLD_SIZE", "1")) + +# I=512 keeps every TP=1/2/4/8 shard aligned to the 32-wide GEMM K-tree and +# keeps the SM90 N dimension tile-aligned even at TP=8. +_TOKENS = 32 +_HIDDEN = 64 +_INTERMEDIATE = 512 + +_WORLD2_CONFIGS = ( + ("tp2", 2, 1, False), + ("tp2_sp", 2, 1, True), +) +_WORLD4_CONFIGS = ( + ("tp4", 4, 1, False), + ("tp2_cp2", 2, 2, False), + ("tp2_cp2_sp", 2, 2, True), +) +_WORLD8_CONFIGS = (("tp8", 8, 1, False),) + +pytestmark = pytest.mark.skipif( + _EXTERNAL_WORLD_SIZE != 1, + reason="topology tests own their local worker processes; run pytest directly", +) + + +def _has_topology_devices(count: int) -> bool: + if not ( + torch.cuda.is_available() + and _EXT_AVAILABLE + and _C is not None + and torch.distributed.is_available() + and torch.distributed.is_nccl_available() + and torch.cuda.device_count() >= count + and all(hasattr(_C, name) for name in _REQUIRED_FFN_SYMBOLS) + ): + return False + # ROCm deliberately excludes the CUDA IPC source and uses the public RCCL + # transport collective. NVIDIA still requires all legacy IPC symbols. + return _IS_ROCM or all(hasattr(_C, name) for name in _REQUIRED_CUDA_COLLECTIVE_SYMBOLS) + + +def _has_qwen3_8b_capacity(count: int) -> bool: + if not _has_topology_devices(count): + return False + minimum_bytes = 8 * 1024**3 + try: + return all( + torch.cuda.get_device_properties(index).total_memory >= minimum_bytes + for index in range(count) + ) + except RuntimeError: + return False + + +def _randn( + shape: tuple[int, ...], + *, + seed: int, + device: torch.device, +) -> torch.Tensor: + generator = torch.Generator(device="cpu").manual_seed(seed) + value = torch.randn(*shape, generator=generator, dtype=torch.float32) * 0.02 + return value.to(device=device, dtype=torch.bfloat16) + + +def _make_inputs( + token_count: int, + hidden_size: int, + intermediate_size: int, + device: torch.device, + *, + seed: int, +) -> tuple[torch.Tensor, ...]: + return ( + _randn((token_count, hidden_size), seed=seed, device=device), + _randn((intermediate_size, hidden_size), seed=seed + 1, device=device), + _randn((intermediate_size, hidden_size), seed=seed + 2, device=device), + _randn((hidden_size, intermediate_size), seed=seed + 3, device=device), + _randn((token_count, hidden_size), seed=seed + 4, device=device), + ) + + +def _close_ffn_collectives() -> None: + for collective in list(ffn_module._COLLECTIVES.values()): + collective.close() + ffn_module._COLLECTIVES.clear() + + +def _shard_ranges( + rank: int, + *, + tp_size: int, + cp_size: int, + sequence_parallel: bool, + token_count: int, + intermediate_size: int, +) -> tuple[int, int, int, int]: + if tp_size * cp_size <= rank: + raise ValueError("rank lies outside the requested TP/CP mesh") + if token_count % cp_size: + raise ValueError("token count must be divisible by CP size") + cp_tokens = token_count // cp_size + if sequence_parallel and cp_tokens % tp_size: + raise ValueError("each CP token shard must be divisible by TP size for SP") + if intermediate_size % tp_size: + raise ValueError("intermediate size must be divisible by TP size") + + tp_rank = rank % tp_size + cp_rank = rank // tp_size + local_tokens = cp_tokens // tp_size if sequence_parallel else cp_tokens + token_start = cp_rank * cp_tokens + if sequence_parallel: + token_start += tp_rank * local_tokens + token_end = token_start + local_tokens + + local_intermediate = intermediate_size // tp_size + feature_start = tp_rank * local_intermediate + feature_end = feature_start + local_intermediate + return token_start, token_end, feature_start, feature_end + + +def _canonical( + hidden: torch.Tensor, + gate: torch.Tensor, + up: torch.Tensor, + down: torch.Tensor, + grad_output: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor, list[torch.Tensor]]: + with torch.no_grad(): + inference = qwen3_ffn(hidden, gate, up, down) + inputs = [value.detach().clone().requires_grad_(True) for value in (hidden, gate, up, down)] + training = qwen3_ffn(*inputs) + training.backward(grad_output) + assert torch.equal(inference, training.detach()), "TP=1 train/infer forward mismatch" + return inference, training, inputs + + +def _mesh_groups( + dist: Any, + tp_size: int, + cp_size: int, +) -> tuple[list[Any], list[Any]]: + world_size = dist.get_world_size() + if tp_size * cp_size != world_size: + raise ValueError("TP size times CP size must equal the process-group world size") + if tp_size == world_size and cp_size == 1: + return [dist.group.WORLD], [] + if cp_size == world_size and tp_size == 1: + return [], [dist.group.WORLD] + + tp_groups = [] + if tp_size > 1: + for cp_rank in range(cp_size): + ranks = list(range(cp_rank * tp_size, (cp_rank + 1) * tp_size)) + tp_groups.append(dist.new_group(ranks=ranks)) + + cp_groups = [] + if cp_size > 1: + for tp_rank in range(tp_size): + ranks = [cp_rank * tp_size + tp_rank for cp_rank in range(cp_size)] + cp_groups.append(dist.new_group(ranks=ranks)) + return tp_groups, cp_groups + + +def _run_topology( + rank: int, + dist: Any, + meshes: dict[tuple[int, int], tuple[list[Any], list[Any]]], + *, + name: str, + tp_size: int, + cp_size: int, + sequence_parallel: bool, + hidden: torch.Tensor, + gate: torch.Tensor, + up: torch.Tensor, + down: torch.Tensor, + grad_output: torch.Tensor, + inference_reference: torch.Tensor, + training_reference: torch.Tensor, + reference_inputs: list[torch.Tensor], +) -> None: + mesh_key = (tp_size, cp_size) + if mesh_key not in meshes: + meshes[mesh_key] = _mesh_groups(dist, tp_size, cp_size) + tp_groups, cp_groups = meshes[mesh_key] + + tp_rank = rank % tp_size + cp_rank = rank // tp_size + tp_group = tp_groups[cp_rank] if tp_size > 1 else None + cp_group = cp_groups[tp_rank] if cp_size > 1 else None + token_start, token_end, feature_start, feature_end = _shard_ranges( + rank, + tp_size=tp_size, + cp_size=cp_size, + sequence_parallel=sequence_parallel, + token_count=hidden.size(0), + intermediate_size=gate.size(0), + ) + shard = ( + hidden[token_start:token_end].contiguous(), + gate[feature_start:feature_end].contiguous(), + up[feature_start:feature_end].contiguous(), + down[:, feature_start:feature_end].contiguous(), + ) + + with torch.no_grad(): + inference = qwen3_ffn( + *shard, + tp_group=tp_group, + cp_group=cp_group, + sequence_parallel=sequence_parallel, + ) + inputs = [value.detach().clone().requires_grad_(True) for value in shard] + training = qwen3_ffn( + *inputs, + tp_group=tp_group, + cp_group=cp_group, + sequence_parallel=sequence_parallel, + ) + training.backward(grad_output[token_start:token_end].contiguous()) + + expected_output = inference_reference[token_start:token_end] + assert torch.equal(inference, training.detach()), f"{name}: train/infer mismatch" + assert torch.equal(inference, expected_output), f"{name}: inference mismatch vs TP=1" + assert torch.equal(training.detach(), training_reference.detach()[token_start:token_end]), ( + f"{name}: training forward mismatch vs TP=1" + ) + assert torch.equal(inputs[0].grad, reference_inputs[0].grad[token_start:token_end]), ( + f"{name}: hidden grad mismatch vs TP=1" + ) + + expected_weight_grads = ( + (inputs[1].grad, reference_inputs[1].grad[feature_start:feature_end], "gate"), + (inputs[2].grad, reference_inputs[2].grad[feature_start:feature_end], "up"), + ( + inputs[3].grad, + reference_inputs[3].grad[:, feature_start:feature_end], + "down", + ), + ) + for actual, expected, label in expected_weight_grads: + assert torch.equal(actual, expected), f"{name}: {label} weight grad mismatch vs TP=1" + + +def _topology_worker( + rank: int, + world_size: int, + init_method: str, + result_queue: Any, + configs: tuple[tuple[str, int, int, bool], ...], +) -> None: + try: + import torch.distributed as dist + + torch.cuda.set_device(rank) + dist.init_process_group( + backend="nccl", + init_method=init_method, + rank=rank, + world_size=world_size, + timeout=timedelta(minutes=5), + ) + device = torch.device("cuda", rank) + hidden, gate, up, down, grad_output = _make_inputs( + _TOKENS, + _HIDDEN, + _INTERMEDIATE, + device, + seed=600, + ) + inference_reference, training_reference, reference_inputs = _canonical( + hidden, + gate, + up, + down, + grad_output, + ) + meshes: dict[tuple[int, int], tuple[list[Any], list[Any]]] = {} + for name, tp_size, cp_size, sequence_parallel in configs: + _run_topology( + rank, + dist, + meshes, + name=name, + tp_size=tp_size, + cp_size=cp_size, + sequence_parallel=sequence_parallel, + hidden=hidden, + gate=gate, + up=up, + down=down, + grad_output=grad_output, + inference_reference=inference_reference, + training_reference=training_reference, + reference_inputs=reference_inputs, + ) + result_queue.put({"ok": True, "rank": rank}) + except Exception: # pragma: no cover - forwarded to the parent process. + result_queue.put({"ok": False, "rank": rank, "traceback": traceback.format_exc()}) + raise + finally: + _close_ffn_collectives() + if torch.distributed.is_available() and torch.distributed.is_initialized(): + torch.distributed.destroy_process_group() + + +def _qwen3_8b_tp2_worker( + rank: int, + world_size: int, + init_method: str, + result_queue: Any, +) -> None: + try: + import torch.distributed as dist + + torch.cuda.set_device(rank) + dist.init_process_group( + backend="nccl", + init_method=init_method, + rank=rank, + world_size=world_size, + timeout=timedelta(minutes=10), + ) + device = torch.device("cuda", rank) + hidden, gate, up, down, grad_output = _make_inputs( + 2, + QWEN3_8B_HIDDEN_SIZE, + QWEN3_8B_INTERMEDIATE_SIZE, + device, + seed=800, + ) + inference_reference, training_reference, reference_inputs = _canonical( + hidden, + gate, + up, + down, + grad_output, + ) + _run_topology( + rank, + dist, + {}, + name="qwen3_8b_tp2", + tp_size=2, + cp_size=1, + sequence_parallel=False, + hidden=hidden, + gate=gate, + up=up, + down=down, + grad_output=grad_output, + inference_reference=inference_reference, + training_reference=training_reference, + reference_inputs=reference_inputs, + ) + result_queue.put({"ok": True, "rank": rank}) + except Exception: # pragma: no cover - forwarded to the parent process. + result_queue.put({"ok": False, "rank": rank, "traceback": traceback.format_exc()}) + raise + finally: + _close_ffn_collectives() + if torch.distributed.is_available() and torch.distributed.is_initialized(): + torch.distributed.destroy_process_group() + + +def _spawn_workers( + worker: Any, + world_size: int, + worker_args: tuple[Any, ...] = (), + *, + timeout_seconds: int, +) -> None: + if not _has_topology_devices(world_size): + platform = "ROCm/RCCL" if _IS_ROCM else "CUDA/NCCL" + pytest.skip( + f"requires {world_size} {platform} GPUs plus FFN and deterministic collective support" + ) + + # Single-GPU tests may have populated the parent process's caching + # allocator on device 0. Release unused blocks before spawned rank 0 owns + # that device, which matters for the Qwen3-8B smoke case. + torch.cuda.empty_cache() + ctx = mp.get_context("spawn") + with tempfile.TemporaryDirectory() as temporary_directory: + init_method = (Path(temporary_directory) / "nccl_init").as_uri() + result_queue = ctx.Queue() + processes = [ + ctx.Process( + target=worker, + args=(rank, world_size, init_method, result_queue, *worker_args), + ) + for rank in range(world_size) + ] + for process in processes: + process.start() + + results = [] + try: + for _ in processes: + result = result_queue.get(timeout=timeout_seconds) + results.append(result) + if not result["ok"]: + for process in processes: + if process.is_alive(): + process.terminate() + break + except queue.Empty: + for process in processes: + if process.is_alive(): + process.terminate() + pytest.fail(f"timed out waiting for {world_size} FFN topology workers") + finally: + for process in processes: + process.join(timeout=10) + if process.is_alive(): + process.terminate() + process.join(timeout=10) + result_queue.close() + result_queue.join_thread() + + for result in sorted(results, key=lambda item: item["rank"]): + assert result["ok"], result.get("traceback") + for process in processes: + assert process.exitcode == 0 + + +def test_qwen3_ffn_tp2_and_tp_sp_match_tp1_bitwise() -> None: + _spawn_workers( + _topology_worker, + 2, + (_WORLD2_CONFIGS,), + timeout_seconds=180, + ) + + +def test_qwen3_ffn_tp4_tp_cp_and_tp_cp_sp_match_tp1_bitwise() -> None: + _spawn_workers( + _topology_worker, + 4, + (_WORLD4_CONFIGS,), + timeout_seconds=240, + ) + + +def test_qwen3_ffn_tp8_matches_tp1_bitwise() -> None: + _spawn_workers( + _topology_worker, + 8, + (_WORLD8_CONFIGS,), + timeout_seconds=360, + ) + + +def test_qwen3_8b_ffn_tp2_smoke_matches_tp1_bitwise() -> None: + if os.environ.get("RL_KERNEL_SKIP_QWEN3_8B_TOPOLOGY") == "1": + pytest.skip("Qwen3-8B topology smoke disabled by environment") + if not _has_qwen3_8b_capacity(2): + pytest.skip("Qwen3-8B TP=2 smoke requires two GPUs with at least 8 GiB each") + _spawn_workers( + _qwen3_8b_tp2_worker, + 2, + timeout_seconds=600, + ) From 7d04efe80f7903431bc75fff3bbbe85eb82e02c4 Mon Sep 17 00:00:00 2001 From: frank-2077 Date: Fri, 21 Aug 2026 14:57:38 +0000 Subject: [PATCH 06/28] test(ffn): allow ROCm RCCL teardown to complete --- tests/distributed/test_qwen_ffn_topology.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tests/distributed/test_qwen_ffn_topology.py b/tests/distributed/test_qwen_ffn_topology.py index c68afb9e..44de9041 100644 --- a/tests/distributed/test_qwen_ffn_topology.py +++ b/tests/distributed/test_qwen_ffn_topology.py @@ -459,10 +459,15 @@ def _spawn_workers( pytest.fail(f"timed out waiting for {world_size} FFN topology workers") finally: for process in processes: - process.join(timeout=10) + # RCCL teardown can take longer than ten seconds after every + # worker has already reported a successful result, especially + # for the eight-rank topology on ROCm hosts with unusable RDMA + # interfaces. Allow cleanup to finish instead of turning a + # successful numerical check into a SIGTERM false failure. + process.join(timeout=30) if process.is_alive(): process.terminate() - process.join(timeout=10) + process.join(timeout=30) result_queue.close() result_queue.join_thread() From 2f3f61d910677842be118f95bbab6cfbcf75f0f1 Mon Sep 17 00:00:00 2001 From: frank-2077 Date: Fri, 21 Aug 2026 16:09:04 +0000 Subject: [PATCH 07/28] perf: benchmark deterministic FFN on ROCm --- benchmarks/benchmark_rocm_ffn.py | 1712 +++++++++++++++ .../pr325_rocm_mi300x/accuracy_tradeoff.png | Bin 0 -> 93854 bytes .../pr325_rocm_mi300x/collective_overhead.png | Bin 0 -> 168873 bytes .../distributed_ffn_overhead.png | Bin 0 -> 92815 bytes .../results/pr325_rocm_mi300x/report.md | 147 ++ .../results/pr325_rocm_mi300x/results.json | 1859 +++++++++++++++++ .../pr325_rocm_mi300x/single_gpu_overhead.png | Bin 0 -> 213116 bytes 7 files changed, 3718 insertions(+) create mode 100644 benchmarks/benchmark_rocm_ffn.py create mode 100644 benchmarks/results/pr325_rocm_mi300x/accuracy_tradeoff.png create mode 100644 benchmarks/results/pr325_rocm_mi300x/collective_overhead.png create mode 100644 benchmarks/results/pr325_rocm_mi300x/distributed_ffn_overhead.png create mode 100644 benchmarks/results/pr325_rocm_mi300x/report.md create mode 100644 benchmarks/results/pr325_rocm_mi300x/results.json create mode 100644 benchmarks/results/pr325_rocm_mi300x/single_gpu_overhead.png diff --git a/benchmarks/benchmark_rocm_ffn.py b/benchmarks/benchmark_rocm_ffn.py new file mode 100644 index 00000000..8cc3f895 --- /dev/null +++ b/benchmarks/benchmark_rocm_ffn.py @@ -0,0 +1,1712 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 RL-Kernel Contributors +"""ROCm performance and accuracy analysis for the deterministic Qwen3 FFN. + +This benchmark compares the deterministic PR #325 path against native ROCm +operators without loading a model: + +* deterministic GEMM vs ``torch.matmul`` (rocBLAS/hipBLASLt); +* deterministic SwiGLU vs native PyTorch elementwise operators; +* deterministic collectives vs native RCCL through ProcessGroupNCCL; +* deterministic FFN vs a native ROCm/RCCL implementation with the same TP/CP/SP + sharding and collective schedule. + +The script writes raw JSON, Markdown tables, and PNG figures. GPU events are +used for single-GPU operators. Distributed timings use synchronized wall +clock samples and report the slowest rank for each iteration. +""" + +from __future__ import annotations + +import argparse +import json +import math +import os +import queue +import statistics +import tempfile +import time +import traceback +from datetime import timedelta +from pathlib import Path +from typing import Any, Callable + +import torch +import torch.distributed as dist +import torch.multiprocessing as mp +import torch.nn.functional as F + +import rl_engine.kernels.ops.pytorch.ffn.ffn as ffn_module +from rl_engine.distributed import RCCLDeterministicCollective +from rl_engine.kernels.ops.base import _C, _EXT_AVAILABLE +from rl_engine.kernels.ops.cuda.matmul import deterministic_gemm +from rl_engine.kernels.ops.pytorch.ffn import qwen3_ffn + +_MIB = 1024 * 1024 +_REQUIRED_SYMBOLS = ( + "det_gemm_fwd", + "det_gemm_db", + "swiglu_forward", + "swiglu_backward", +) +_DISTRIBUTED_CONFIGS: dict[int, tuple[tuple[str, int, int, bool], ...]] = { + 2: ( + ("tp2", 2, 1, False), + ("tp2_sp", 2, 1, True), + ), + 4: ( + ("tp4", 4, 1, False), + ("tp2_cp2", 2, 2, False), + ("tp2_cp2_sp", 2, 2, True), + ), + 8: ( + ("tp8", 8, 1, False), + ("tp4_cp2", 4, 2, False), + ("tp4_cp2_sp", 4, 2, True), + ), +} + + +def _percentile(values: list[float], percentile: float) -> float: + ordered = sorted(values) + if not ordered: + return float("nan") + position = (len(ordered) - 1) * percentile + lower = math.floor(position) + upper = math.ceil(position) + if lower == upper: + return ordered[lower] + weight = position - lower + return ordered[lower] * (1.0 - weight) + ordered[upper] * weight + + +def _summary_ms(values: list[float]) -> dict[str, float]: + return { + "median_ms": statistics.median(values), + "p95_ms": _percentile(values, 0.95), + "min_ms": min(values), + "max_ms": max(values), + } + + +def _relative_l2(actual: torch.Tensor, expected: torch.Tensor) -> float: + actual_float = actual.detach().float() + expected_float = expected.detach().float() + denominator = torch.linalg.vector_norm(expected_float) + if denominator.item() == 0.0: + return float(torch.linalg.vector_norm(actual_float - expected_float).item()) + return float((torch.linalg.vector_norm(actual_float - expected_float) / denominator).item()) + + +def _accuracy(actual: torch.Tensor, expected: torch.Tensor) -> dict[str, float]: + difference = actual.detach().float() - expected.detach().float() + return { + "max_abs": float(difference.abs().max().item()), + "mean_abs": float(difference.abs().mean().item()), + "relative_l2": _relative_l2(actual, expected), + "exact_fraction": float((actual.detach() == expected.detach()).float().mean().item()), + } + + +def _randn( + shape: tuple[int, ...], + *, + seed: int, + device: torch.device, + scale: float = 0.02, +) -> torch.Tensor: + generator = torch.Generator(device="cpu").manual_seed(seed) + value = torch.randn(shape, generator=generator, dtype=torch.float32) * scale + return value.to(device=device, dtype=torch.bfloat16) + + +def _gpu_event_samples( + function: Callable[[], Any], + *, + warmup: int, + samples: int, +) -> list[float]: + for _ in range(warmup): + function() + torch.cuda.synchronize() + + events: list[tuple[torch.cuda.Event, torch.cuda.Event]] = [] + for _ in range(samples): + start = torch.cuda.Event(enable_timing=True) + end = torch.cuda.Event(enable_timing=True) + start.record() + function() + end.record() + events.append((start, end)) + torch.cuda.synchronize() + return [float(start.elapsed_time(end)) for start, end in events] + + +def _native_ffn( + hidden: torch.Tensor, + gate_weight: torch.Tensor, + up_weight: torch.Tensor, + down_weight: torch.Tensor, +) -> torch.Tensor: + gate = hidden @ gate_weight.t() + up = hidden @ up_weight.t() + activated = F.silu(gate) * up + return activated @ down_weight.t() + + +def _single_gpu_benchmarks( + *, + warmup: int, + samples: int, + training_samples: int, +) -> dict[str, list[dict[str, Any]]]: + device = torch.device("cuda", 0) + torch.cuda.set_device(device) + torch.backends.cuda.matmul.allow_tf32 = False + + results: dict[str, list[dict[str, Any]]] = { + "gemm": [], + "swiglu": [], + "ffn": [], + } + + gemm_shapes = [] + for tokens in (1, 8, 32, 128): + gemm_shapes.extend( + ( + (f"gate_up_m{tokens}", tokens, 4096, 12288), + (f"down_m{tokens}", tokens, 12288, 4096), + ) + ) + + for shape_index, (name, m_size, k_size, n_size) in enumerate(gemm_shapes): + left = _randn((m_size, k_size), seed=1000 + shape_index * 2, device=device) + right = _randn((k_size, n_size), seed=1001 + shape_index * 2, device=device) + native_output = torch.matmul(left, right) + deterministic_output = deterministic_gemm(left, right) + fp32_reference = left.float() @ right.float() + torch.cuda.synchronize() + + native_samples = _gpu_event_samples( + lambda: torch.matmul(left, right), warmup=warmup, samples=samples + ) + deterministic_samples = _gpu_event_samples( + lambda: deterministic_gemm(left, right), warmup=warmup, samples=samples + ) + native_timing = _summary_ms(native_samples) + deterministic_timing = _summary_ms(deterministic_samples) + results["gemm"].append( + { + "name": name, + "m": m_size, + "k": k_size, + "n": n_size, + "dtype": "bfloat16", + "native": native_timing, + "deterministic": deterministic_timing, + "overhead_ratio": ( + deterministic_timing["median_ms"] / native_timing["median_ms"] + ), + "deterministic_vs_native": _accuracy( + deterministic_output, native_output + ), + "native_vs_fp32": _accuracy(native_output, fp32_reference), + "deterministic_vs_fp32": _accuracy( + deterministic_output, fp32_reference + ), + } + ) + del left, right, native_output, deterministic_output, fp32_reference + torch.cuda.empty_cache() + + for case_index, tokens in enumerate((1, 8, 32, 128)): + gate = _randn((tokens, 12288), seed=2000 + case_index * 3, device=device) + up = _randn((tokens, 12288), seed=2001 + case_index * 3, device=device) + grad_output = _randn( + (tokens, 12288), seed=2002 + case_index * 3, device=device + ) + + native_forward = F.silu(gate) * up + deterministic_forward = _C.swiglu_forward(gate, up) + + def native_backward() -> tuple[torch.Tensor, torch.Tensor]: + sigmoid = torch.sigmoid(gate) + grad_gate = grad_output * up * sigmoid * (1.0 + gate * (1.0 - sigmoid)) + grad_up = grad_output * F.silu(gate) + return grad_gate, grad_up + + native_grad_gate, native_grad_up = native_backward() + deterministic_grad_gate, deterministic_grad_up = _C.swiglu_backward( + grad_output, gate, up + ) + + for direction, native_function, deterministic_function in ( + ( + "forward", + lambda: F.silu(gate) * up, + lambda: _C.swiglu_forward(gate, up), + ), + ( + "backward", + native_backward, + lambda: _C.swiglu_backward(grad_output, gate, up), + ), + ): + native_timing = _summary_ms( + _gpu_event_samples( + native_function, warmup=warmup, samples=samples + ) + ) + deterministic_timing = _summary_ms( + _gpu_event_samples( + deterministic_function, warmup=warmup, samples=samples + ) + ) + if direction == "forward": + accuracy = _accuracy(deterministic_forward, native_forward) + else: + accuracy = { + "max_abs": max( + _accuracy(deterministic_grad_gate, native_grad_gate)["max_abs"], + _accuracy(deterministic_grad_up, native_grad_up)["max_abs"], + ), + "relative_l2": max( + _relative_l2(deterministic_grad_gate, native_grad_gate), + _relative_l2(deterministic_grad_up, native_grad_up), + ), + } + results["swiglu"].append( + { + "name": f"swiglu_{direction}_m{tokens}", + "direction": direction, + "tokens": tokens, + "intermediate": 12288, + "dtype": "bfloat16", + "native": native_timing, + "deterministic": deterministic_timing, + "overhead_ratio": ( + deterministic_timing["median_ms"] / native_timing["median_ms"] + ), + "deterministic_vs_native": accuracy, + } + ) + + del gate, up, grad_output + torch.cuda.empty_cache() + + gate_weight = _randn((12288, 4096), seed=3000, device=device) + up_weight = _randn((12288, 4096), seed=3001, device=device) + down_weight = _randn((4096, 12288), seed=3002, device=device) + for case_index, tokens in enumerate((1, 8, 32)): + hidden = _randn((tokens, 4096), seed=3010 + case_index * 2, device=device) + grad_output = _randn( + (tokens, 4096), seed=3011 + case_index * 2, device=device + ) + with torch.no_grad(): + native_output = _native_ffn(hidden, gate_weight, up_weight, down_weight) + deterministic_output = qwen3_ffn( + hidden, gate_weight, up_weight, down_weight + ) + + native_timing = _summary_ms( + _gpu_event_samples( + lambda: _native_ffn(hidden, gate_weight, up_weight, down_weight), + warmup=warmup, + samples=samples, + ) + ) + deterministic_timing = _summary_ms( + _gpu_event_samples( + lambda: qwen3_ffn(hidden, gate_weight, up_weight, down_weight), + warmup=warmup, + samples=samples, + ) + ) + results["ffn"].append( + { + "name": f"ffn_forward_m{tokens}", + "direction": "forward", + "tokens": tokens, + "hidden": 4096, + "intermediate": 12288, + "dtype": "bfloat16", + "native": native_timing, + "deterministic": deterministic_timing, + "overhead_ratio": ( + deterministic_timing["median_ms"] / native_timing["median_ms"] + ), + "deterministic_vs_native": _accuracy( + deterministic_output, native_output + ), + "train_infer_bitwise": None, + } + ) + + native_inputs = [ + value.detach().clone().requires_grad_(True) + for value in (hidden, gate_weight, up_weight, down_weight) + ] + deterministic_inputs = [ + value.detach().clone().requires_grad_(True) + for value in (hidden, gate_weight, up_weight, down_weight) + ] + + def native_training_step() -> torch.Tensor: + for value in native_inputs: + value.grad = None + output = _native_ffn(*native_inputs) + output.backward(grad_output) + return output + + def deterministic_training_step() -> torch.Tensor: + for value in deterministic_inputs: + value.grad = None + output = qwen3_ffn(*deterministic_inputs) + output.backward(grad_output) + return output + + native_train_output = native_training_step().detach().clone() + native_grads = [value.grad.detach().clone() for value in native_inputs] + deterministic_train_output = deterministic_training_step().detach().clone() + deterministic_grads = [ + value.grad.detach().clone() for value in deterministic_inputs + ] + train_infer_bitwise = torch.equal( + deterministic_output, deterministic_train_output + ) + + native_train_timing = _summary_ms( + _gpu_event_samples( + native_training_step, + warmup=max(1, warmup // 2), + samples=training_samples, + ) + ) + deterministic_train_timing = _summary_ms( + _gpu_event_samples( + deterministic_training_step, + warmup=max(1, warmup // 2), + samples=training_samples, + ) + ) + results["ffn"].append( + { + "name": f"ffn_train_fwd_bwd_m{tokens}", + "direction": "train_fwd_bwd", + "tokens": tokens, + "hidden": 4096, + "intermediate": 12288, + "dtype": "bfloat16", + "native": native_train_timing, + "deterministic": deterministic_train_timing, + "overhead_ratio": ( + deterministic_train_timing["median_ms"] + / native_train_timing["median_ms"] + ), + "deterministic_vs_native": _accuracy( + deterministic_train_output, native_train_output + ), + "max_gradient_relative_l2": max( + _relative_l2(actual, expected) + for actual, expected in zip( + deterministic_grads, native_grads, strict=True + ) + ), + "train_infer_bitwise": bool(train_infer_bitwise), + } + ) + del ( + hidden, + grad_output, + native_inputs, + deterministic_inputs, + native_grads, + deterministic_grads, + ) + torch.cuda.empty_cache() + + return results + + +def _native_all_gather(input_tensor: torch.Tensor, group: Any) -> torch.Tensor: + world_size = dist.get_world_size(group=group) + flat_input = input_tensor.contiguous().view(-1) + flat_output = torch.empty( + world_size * flat_input.numel(), + dtype=input_tensor.dtype, + device=input_tensor.device, + ) + dist.all_gather_into_tensor(flat_output, flat_input, group=group) + return flat_output.reshape( + input_tensor.size(0) * world_size, *input_tensor.shape[1:] + ) + + +def _native_all_reduce(input_tensor: torch.Tensor, group: Any) -> torch.Tensor: + output = input_tensor.clone() + dist.all_reduce(output, group=group) + return output + + +def _native_reduce_scatter(input_tensor: torch.Tensor, group: Any) -> torch.Tensor: + world_size = dist.get_world_size(group=group) + output = torch.empty( + (input_tensor.size(0) // world_size, *input_tensor.shape[1:]), + dtype=input_tensor.dtype, + device=input_tensor.device, + ) + dist.reduce_scatter_tensor(output, input_tensor.contiguous(), group=group) + return output + + +class _NativeDistributedFFNFunction(torch.autograd.Function): + """Native ROCm/RCCL baseline with the PR's collective schedule.""" + + @staticmethod + def forward( + ctx: Any, + hidden: torch.Tensor, + gate_weight: torch.Tensor, + up_weight: torch.Tensor, + down_weight: torch.Tensor, + tp_group: Any, + cp_group: Any, + sequence_parallel: bool, + ) -> torch.Tensor: + input_shape = hidden.shape + hidden_2d = hidden.reshape(-1, hidden.size(-1)).contiguous() + if sequence_parallel: + hidden_2d = _native_all_gather(hidden_2d, tp_group) + + gate = hidden_2d @ gate_weight.t() + up = hidden_2d @ up_weight.t() + activated = F.silu(gate) * up + output = activated @ down_weight.t() + + if sequence_parallel: + output = _native_reduce_scatter(output, tp_group) + elif tp_group is not None: + output = _native_all_reduce(output, tp_group) + + ctx.save_for_backward( + hidden_2d, + gate, + up, + activated, + gate_weight, + up_weight, + down_weight, + ) + ctx.input_shape = input_shape + ctx.tp_group = tp_group + ctx.cp_group = cp_group + ctx.sequence_parallel = sequence_parallel + return output.reshape(*input_shape[:-1], output.size(-1)) + + @staticmethod + def backward(ctx: Any, grad_output: torch.Tensor) -> tuple[Any, ...]: + ( + hidden, + gate, + up, + activated, + gate_weight, + up_weight, + down_weight, + ) = ctx.saved_tensors + grad_output = grad_output.reshape(-1, grad_output.size(-1)).contiguous() + if ctx.sequence_parallel: + grad_output = _native_all_gather(grad_output, ctx.tp_group) + + if ctx.cp_group is not None: + activated_full = _native_all_gather(activated, ctx.cp_group) + grad_output_full = _native_all_gather(grad_output, ctx.cp_group) + grad_down_weight = grad_output_full.t() @ activated_full + else: + grad_down_weight = grad_output.t() @ activated + + grad_activated = grad_output @ down_weight + sigmoid = torch.sigmoid(gate) + grad_gate = grad_activated * up * sigmoid * (1.0 + gate * (1.0 - sigmoid)) + grad_up = grad_activated * F.silu(gate) + + if ctx.cp_group is not None: + hidden_full = _native_all_gather(hidden, ctx.cp_group) + grad_gate_full = _native_all_gather(grad_gate, ctx.cp_group) + grad_up_full = _native_all_gather(grad_up, ctx.cp_group) + grad_gate_weight = grad_gate_full.t() @ hidden_full + grad_up_weight = grad_up_full.t() @ hidden_full + else: + grad_gate_weight = grad_gate.t() @ hidden + grad_up_weight = grad_up.t() @ hidden + + grad_hidden_gate = grad_gate @ gate_weight + if ctx.sequence_parallel: + grad_hidden_gate = _native_reduce_scatter( + grad_hidden_gate, ctx.tp_group + ) + elif ctx.tp_group is not None: + grad_hidden_gate = _native_all_reduce(grad_hidden_gate, ctx.tp_group) + + grad_hidden_up = grad_up @ up_weight + if ctx.sequence_parallel: + grad_hidden_up = _native_reduce_scatter(grad_hidden_up, ctx.tp_group) + elif ctx.tp_group is not None: + grad_hidden_up = _native_all_reduce(grad_hidden_up, ctx.tp_group) + + grad_hidden = grad_hidden_gate.add_(grad_hidden_up) + return ( + grad_hidden.reshape(ctx.input_shape), + grad_gate_weight, + grad_up_weight, + grad_down_weight, + None, + None, + None, + ) + + +def _native_distributed_ffn( + hidden: torch.Tensor, + gate_weight: torch.Tensor, + up_weight: torch.Tensor, + down_weight: torch.Tensor, + *, + tp_group: Any, + cp_group: Any, + sequence_parallel: bool, +) -> torch.Tensor: + return _NativeDistributedFFNFunction.apply( + hidden, + gate_weight, + up_weight, + down_weight, + tp_group, + cp_group, + sequence_parallel, + ) + + +def _mesh_groups( + world_size: int, + tp_size: int, + cp_size: int, +) -> tuple[list[Any], list[Any]]: + if tp_size * cp_size != world_size: + raise ValueError("TP size times CP size must equal world size") + if tp_size == world_size and cp_size == 1: + return [dist.group.WORLD], [] + + tp_groups = [] + if tp_size > 1: + for cp_rank in range(cp_size): + ranks = list(range(cp_rank * tp_size, (cp_rank + 1) * tp_size)) + tp_groups.append(dist.new_group(ranks=ranks)) + + cp_groups = [] + if cp_size > 1: + for tp_rank in range(tp_size): + ranks = [cp_rank * tp_size + tp_rank for cp_rank in range(cp_size)] + cp_groups.append(dist.new_group(ranks=ranks)) + return tp_groups, cp_groups + + +def _shard_ranges( + rank: int, + *, + tp_size: int, + cp_size: int, + sequence_parallel: bool, + token_count: int, + intermediate_size: int, +) -> tuple[int, int, int, int]: + tp_rank = rank % tp_size + cp_rank = rank // tp_size + cp_tokens = token_count // cp_size + local_tokens = cp_tokens // tp_size if sequence_parallel else cp_tokens + token_start = cp_rank * cp_tokens + if sequence_parallel: + token_start += tp_rank * local_tokens + token_end = token_start + local_tokens + + local_intermediate = intermediate_size // tp_size + feature_start = tp_rank * local_intermediate + feature_end = feature_start + local_intermediate + return token_start, token_end, feature_start, feature_end + + +def _distributed_wall_samples( + function: Callable[[], Any], + *, + group: Any, + warmup: int, + samples: int, +) -> list[float]: + for _ in range(warmup): + function() + torch.cuda.synchronize() + dist.barrier(group=group) + + timings = [] + for _ in range(samples): + torch.cuda.synchronize() + start = time.perf_counter() + function() + torch.cuda.synchronize() + timings.append((time.perf_counter() - start) * 1000.0) + dist.barrier(group=group) + return timings + + +def _slowest_rank_summary(local_timings: list[float], group: Any) -> dict[str, float]: + world_size = dist.get_world_size(group=group) + gathered: list[list[float] | None] = [None] * world_size + dist.all_gather_object(gathered, local_timings, group=group) + slowest_per_sample = [ + max(float(rank_timings[index]) for rank_timings in gathered if rank_timings is not None) + for index in range(len(local_timings)) + ] + return _summary_ms(slowest_per_sample) + + +def _collective_benchmarks( + rank: int, + world_size: int, + *, + warmup: int, + samples: int, +) -> list[dict[str, Any]]: + device = torch.device("cuda", rank) + results = [] + for message_bytes in (64 * 1024, 1 * _MIB, 16 * _MIB): + elements = message_bytes // torch.tensor([], dtype=torch.bfloat16).element_size() + input_tensor = torch.zeros(elements, dtype=torch.bfloat16, device=device) + deterministic = RCCLDeterministicCollective( + group=dist.group.WORLD, + device=device, + max_size_bytes=message_bytes, + ) + deterministic_outputs = { + "all_reduce": torch.empty_like(input_tensor), + "all_gather": torch.empty( + elements * world_size, dtype=input_tensor.dtype, device=device + ), + "reduce_scatter": torch.empty( + elements // world_size, dtype=input_tensor.dtype, device=device + ), + } + native_outputs = { + "all_gather": torch.empty( + elements * world_size, dtype=input_tensor.dtype, device=device + ), + "reduce_scatter": torch.empty( + elements // world_size, dtype=input_tensor.dtype, device=device + ), + } + + def deterministic_all_reduce() -> torch.Tensor: + return deterministic.all_reduce( + input_tensor, out=deterministic_outputs["all_reduce"] + ) + + def native_all_reduce() -> torch.Tensor: + dist.all_reduce(input_tensor, group=dist.group.WORLD) + return input_tensor + + def deterministic_all_gather() -> torch.Tensor: + return deterministic.all_gather( + input_tensor, out=deterministic_outputs["all_gather"] + ) + + def native_all_gather() -> torch.Tensor: + dist.all_gather_into_tensor( + native_outputs["all_gather"], input_tensor, group=dist.group.WORLD + ) + return native_outputs["all_gather"] + + def deterministic_reduce_scatter() -> torch.Tensor: + return deterministic.reduce_scatter( + input_tensor, out=deterministic_outputs["reduce_scatter"] + ) + + def native_reduce_scatter() -> torch.Tensor: + dist.reduce_scatter_tensor( + native_outputs["reduce_scatter"], + input_tensor, + group=dist.group.WORLD, + ) + return native_outputs["reduce_scatter"] + + for operation, native_function, deterministic_function in ( + ("all_reduce", native_all_reduce, deterministic_all_reduce), + ("all_gather", native_all_gather, deterministic_all_gather), + ( + "reduce_scatter", + native_reduce_scatter, + deterministic_reduce_scatter, + ), + ): + native_timings = _distributed_wall_samples( + native_function, + group=dist.group.WORLD, + warmup=warmup, + samples=samples, + ) + deterministic_timings = _distributed_wall_samples( + deterministic_function, + group=dist.group.WORLD, + warmup=warmup, + samples=samples, + ) + native_summary = _slowest_rank_summary( + native_timings, dist.group.WORLD + ) + deterministic_summary = _slowest_rank_summary( + deterministic_timings, dist.group.WORLD + ) + accuracy_elements = min(elements, 64 * 1024) + accuracy_input = _randn( + (accuracy_elements,), + seed=4000 + world_size * 100 + rank, + device=device, + scale=1.0, + ) + gathered_accuracy_input = torch.empty( + world_size * accuracy_elements, + dtype=accuracy_input.dtype, + device=device, + ) + dist.all_gather_into_tensor( + gathered_accuracy_input, + accuracy_input, + group=dist.group.WORLD, + ) + rank_inputs = gathered_accuracy_input.reshape( + world_size, accuracy_elements + ) + if operation == "all_reduce": + native_accuracy_output = accuracy_input.clone() + dist.all_reduce(native_accuracy_output, group=dist.group.WORLD) + deterministic_accuracy_output = deterministic.all_reduce( + accuracy_input + ) + fp32_reference = rank_inputs.float().sum(dim=0) + elif operation == "all_gather": + native_accuracy_output = torch.empty_like(gathered_accuracy_input) + dist.all_gather_into_tensor( + native_accuracy_output, + accuracy_input, + group=dist.group.WORLD, + ) + deterministic_accuracy_output = deterministic.all_gather( + accuracy_input + ) + fp32_reference = gathered_accuracy_input.float() + else: + native_accuracy_output = torch.empty( + accuracy_elements // world_size, + dtype=accuracy_input.dtype, + device=device, + ) + dist.reduce_scatter_tensor( + native_accuracy_output, + accuracy_input, + group=dist.group.WORLD, + ) + deterministic_accuracy_output = deterministic.reduce_scatter( + accuracy_input + ) + reduced_reference = rank_inputs.float().sum(dim=0) + fp32_reference = reduced_reference.chunk(world_size)[rank] + + local_accuracy = { + "deterministic_vs_native": _accuracy( + deterministic_accuracy_output, native_accuracy_output + ), + "native_vs_fp32": _accuracy( + native_accuracy_output, fp32_reference + ), + "deterministic_vs_fp32": _accuracy( + deterministic_accuracy_output, fp32_reference + ), + } + gathered_accuracy: list[dict[str, Any] | None] = [None] * world_size + dist.all_gather_object( + gathered_accuracy, local_accuracy, group=dist.group.WORLD + ) + if rank == 0: + valid_accuracy = [ + value for value in gathered_accuracy if value is not None + ] + results.append( + { + "operation": operation, + "world_size": world_size, + "message_bytes_per_rank": message_bytes, + "dtype": "bfloat16", + "native": native_summary, + "deterministic": deterministic_summary, + "overhead_ratio": ( + deterministic_summary["median_ms"] + / native_summary["median_ms"] + ), + "deterministic_vs_native": { + "max_abs": max( + value["deterministic_vs_native"]["max_abs"] + for value in valid_accuracy + ), + "relative_l2": max( + value["deterministic_vs_native"]["relative_l2"] + for value in valid_accuracy + ), + "exact_fraction": min( + value["deterministic_vs_native"]["exact_fraction"] + for value in valid_accuracy + ), + }, + "native_vs_fp32_relative_l2": max( + value["native_vs_fp32"]["relative_l2"] + for value in valid_accuracy + ), + "deterministic_vs_fp32_relative_l2": max( + value["deterministic_vs_fp32"]["relative_l2"] + for value in valid_accuracy + ), + } + ) + del ( + accuracy_input, + gathered_accuracy_input, + rank_inputs, + native_accuracy_output, + deterministic_accuracy_output, + fp32_reference, + ) + deterministic.close() + del input_tensor, deterministic_outputs, native_outputs + torch.cuda.empty_cache() + return results + + +def _distributed_ffn_benchmark( + rank: int, + world_size: int, + configs: tuple[tuple[str, int, int, bool], ...], + *, + warmup: int, + samples: int, + training_samples: int, +) -> list[dict[str, Any]]: + device = torch.device("cuda", rank) + token_count = 32 + hidden_size = 4096 + intermediate_size = 12288 + hidden_full = _randn((token_count, hidden_size), seed=5000, device=device) + gate_full = _randn( + (intermediate_size, hidden_size), seed=5001, device=device + ) + up_full = _randn((intermediate_size, hidden_size), seed=5002, device=device) + down_full = _randn( + (hidden_size, intermediate_size), seed=5003, device=device + ) + grad_output_full = _randn( + (token_count, hidden_size), seed=5004, device=device + ) + + meshes: dict[tuple[int, int], tuple[list[Any], list[Any]]] = {} + results = [] + for name, tp_size, cp_size, sequence_parallel in configs: + mesh_key = (tp_size, cp_size) + if mesh_key not in meshes: + meshes[mesh_key] = _mesh_groups(world_size, tp_size, cp_size) + tp_groups, cp_groups = meshes[mesh_key] + tp_rank = rank % tp_size + cp_rank = rank // tp_size + tp_group = tp_groups[cp_rank] if tp_size > 1 else None + cp_group = cp_groups[tp_rank] if cp_size > 1 else None + token_start, token_end, feature_start, feature_end = _shard_ranges( + rank, + tp_size=tp_size, + cp_size=cp_size, + sequence_parallel=sequence_parallel, + token_count=token_count, + intermediate_size=intermediate_size, + ) + shard = ( + hidden_full[token_start:token_end].contiguous(), + gate_full[feature_start:feature_end].contiguous(), + up_full[feature_start:feature_end].contiguous(), + down_full[:, feature_start:feature_end].contiguous(), + ) + local_grad_output = grad_output_full[token_start:token_end].contiguous() + + native_forward = lambda: _native_distributed_ffn( + *shard, + tp_group=tp_group, + cp_group=cp_group, + sequence_parallel=sequence_parallel, + ) + deterministic_forward = lambda: qwen3_ffn( + *shard, + tp_group=tp_group, + cp_group=cp_group, + sequence_parallel=sequence_parallel, + ) + + with torch.no_grad(): + native_output = native_forward() + deterministic_output = deterministic_forward() + deterministic_repeat = deterministic_forward() + torch.cuda.synchronize() + + native_forward_timings = _distributed_wall_samples( + native_forward, + group=dist.group.WORLD, + warmup=warmup, + samples=samples, + ) + deterministic_forward_timings = _distributed_wall_samples( + deterministic_forward, + group=dist.group.WORLD, + warmup=warmup, + samples=samples, + ) + native_forward_summary = _slowest_rank_summary( + native_forward_timings, dist.group.WORLD + ) + deterministic_forward_summary = _slowest_rank_summary( + deterministic_forward_timings, dist.group.WORLD + ) + + native_inputs = [value.detach().clone().requires_grad_(True) for value in shard] + deterministic_inputs = [ + value.detach().clone().requires_grad_(True) for value in shard + ] + + def native_training_step() -> torch.Tensor: + for value in native_inputs: + value.grad = None + output = _native_distributed_ffn( + *native_inputs, + tp_group=tp_group, + cp_group=cp_group, + sequence_parallel=sequence_parallel, + ) + output.backward(local_grad_output) + return output + + def deterministic_training_step() -> torch.Tensor: + for value in deterministic_inputs: + value.grad = None + output = qwen3_ffn( + *deterministic_inputs, + tp_group=tp_group, + cp_group=cp_group, + sequence_parallel=sequence_parallel, + ) + output.backward(local_grad_output) + return output + + native_train_output = native_training_step().detach().clone() + native_grads = [value.grad.detach().clone() for value in native_inputs] + deterministic_train_output = deterministic_training_step().detach().clone() + deterministic_grads = [ + value.grad.detach().clone() for value in deterministic_inputs + ] + torch.cuda.synchronize() + + native_train_timings = _distributed_wall_samples( + native_training_step, + group=dist.group.WORLD, + warmup=max(1, warmup // 2), + samples=training_samples, + ) + deterministic_train_timings = _distributed_wall_samples( + deterministic_training_step, + group=dist.group.WORLD, + warmup=max(1, warmup // 2), + samples=training_samples, + ) + native_train_summary = _slowest_rank_summary( + native_train_timings, dist.group.WORLD + ) + deterministic_train_summary = _slowest_rank_summary( + deterministic_train_timings, dist.group.WORLD + ) + + local_accuracy = { + "output_relative_l2": _relative_l2( + deterministic_output, native_output + ), + "output_max_abs": _accuracy( + deterministic_output, native_output + )["max_abs"], + "max_gradient_relative_l2": max( + _relative_l2(actual, expected) + for actual, expected in zip( + deterministic_grads, native_grads, strict=True + ) + ), + "train_infer_bitwise": torch.equal( + deterministic_output, deterministic_train_output + ), + "repeat_bitwise": torch.equal( + deterministic_output, deterministic_repeat + ), + } + gathered_accuracy: list[dict[str, Any] | None] = [None] * world_size + dist.all_gather_object( + gathered_accuracy, local_accuracy, group=dist.group.WORLD + ) + if rank == 0: + valid_accuracy = [value for value in gathered_accuracy if value is not None] + results.extend( + ( + { + "name": name, + "direction": "forward", + "world_size": world_size, + "tp_size": tp_size, + "cp_size": cp_size, + "sequence_parallel": sequence_parallel, + "tokens": token_count, + "hidden": hidden_size, + "intermediate": intermediate_size, + "native": native_forward_summary, + "deterministic": deterministic_forward_summary, + "overhead_ratio": ( + deterministic_forward_summary["median_ms"] + / native_forward_summary["median_ms"] + ), + "output_relative_l2": max( + value["output_relative_l2"] for value in valid_accuracy + ), + "output_max_abs": max( + value["output_max_abs"] for value in valid_accuracy + ), + "train_infer_bitwise": all( + value["train_infer_bitwise"] for value in valid_accuracy + ), + "repeat_bitwise": all( + value["repeat_bitwise"] for value in valid_accuracy + ), + }, + { + "name": name, + "direction": "train_fwd_bwd", + "world_size": world_size, + "tp_size": tp_size, + "cp_size": cp_size, + "sequence_parallel": sequence_parallel, + "tokens": token_count, + "hidden": hidden_size, + "intermediate": intermediate_size, + "native": native_train_summary, + "deterministic": deterministic_train_summary, + "overhead_ratio": ( + deterministic_train_summary["median_ms"] + / native_train_summary["median_ms"] + ), + "output_relative_l2": max( + _relative_l2( + deterministic_train_output, native_train_output + ), + *(value["output_relative_l2"] for value in valid_accuracy), + ), + "max_gradient_relative_l2": max( + value["max_gradient_relative_l2"] + for value in valid_accuracy + ), + "train_infer_bitwise": all( + value["train_infer_bitwise"] for value in valid_accuracy + ), + "repeat_bitwise": all( + value["repeat_bitwise"] for value in valid_accuracy + ), + }, + ) + ) + + del ( + shard, + local_grad_output, + native_inputs, + deterministic_inputs, + native_grads, + deterministic_grads, + ) + torch.cuda.empty_cache() + dist.barrier(group=dist.group.WORLD) + + for collective in list(ffn_module._COLLECTIVES.values()): + collective.close() + ffn_module._COLLECTIVES.clear() + return results + + +def _distributed_worker( + rank: int, + world_size: int, + init_method: str, + result_queue: Any, + warmup: int, + samples: int, + training_samples: int, +) -> None: + try: + torch.cuda.set_device(rank) + dist.init_process_group( + backend="nccl", + init_method=init_method, + rank=rank, + world_size=world_size, + timeout=timedelta(minutes=15), + ) + collective_results = _collective_benchmarks( + rank, + world_size, + warmup=warmup, + samples=samples, + ) + ffn_results = _distributed_ffn_benchmark( + rank, + world_size, + _DISTRIBUTED_CONFIGS[world_size], + warmup=warmup, + samples=samples, + training_samples=training_samples, + ) + if rank == 0: + result_queue.put( + { + "ok": True, + "world_size": world_size, + "collectives": collective_results, + "distributed_ffn": ffn_results, + } + ) + except Exception: + result_queue.put( + { + "ok": False, + "rank": rank, + "world_size": world_size, + "traceback": traceback.format_exc(), + } + ) + raise + finally: + for collective in list(ffn_module._COLLECTIVES.values()): + collective.close() + ffn_module._COLLECTIVES.clear() + if dist.is_available() and dist.is_initialized(): + dist.destroy_process_group() + + +def _run_distributed_world( + world_size: int, + *, + warmup: int, + samples: int, + training_samples: int, +) -> dict[str, Any]: + context = mp.get_context("spawn") + with tempfile.TemporaryDirectory() as temporary_directory: + init_method = (Path(temporary_directory) / "rccl_init").as_uri() + result_queue = context.Queue() + processes = [ + context.Process( + target=_distributed_worker, + args=( + rank, + world_size, + init_method, + result_queue, + warmup, + samples, + training_samples, + ), + ) + for rank in range(world_size) + ] + for process in processes: + process.start() + + result = None + try: + result = result_queue.get(timeout=1800) + if not result["ok"]: + for process in processes: + if process.is_alive(): + process.terminate() + except queue.Empty as exc: + for process in processes: + if process.is_alive(): + process.terminate() + raise RuntimeError( + f"timed out waiting for world_size={world_size} benchmark" + ) from exc + finally: + for process in processes: + process.join(timeout=60) + if process.is_alive(): + process.terminate() + process.join(timeout=30) + result_queue.close() + result_queue.join_thread() + + if result is None: + raise RuntimeError(f"world_size={world_size} returned no result") + if not result["ok"]: + raise RuntimeError(result.get("traceback", str(result))) + for process in processes: + if process.exitcode != 0: + raise RuntimeError( + f"world_size={world_size} worker exited with {process.exitcode}" + ) + return result + + +def _write_report(payload: dict[str, Any], output_directory: Path) -> None: + gemm_rows = payload["single_gpu"]["gemm"] + swiglu_rows = payload["single_gpu"]["swiglu"] + ffn_rows = payload["single_gpu"]["ffn"] + collective_rows = payload["collectives"] + distributed_rows = payload["distributed_ffn"] + methodology = payload["methodology"] + + def ratio_range(rows: list[dict[str, Any]], digits: int = 1) -> str: + ratios = [row["overhead_ratio"] for row in rows] + return f"{min(ratios):.{digits}f}-{max(ratios):.{digits}f}x" + + forward_rows = [row for row in distributed_rows if row["direction"] == "forward"] + training_rows = [ + row for row in distributed_rows if row["direction"] == "train_fwd_bwd" + ] + reduction_rows = [ + row + for row in collective_rows + if row["operation"] != "all_gather" and row["world_size"] >= 4 + ] + closer_reductions = sum( + row["deterministic_vs_fp32_relative_l2"] + < row["native_vs_fp32_relative_l2"] + for row in reduction_rows + ) + gemm_native_errors = [ + row["native_vs_fp32"]["relative_l2"] * 100.0 for row in gemm_rows + ] + gemm_deterministic_errors = [ + row["deterministic_vs_fp32"]["relative_l2"] * 100.0 for row in gemm_rows + ] + distributed_output_errors = [ + row["output_relative_l2"] * 100.0 for row in distributed_rows + ] + consistency_rows = all( + row["train_infer_bitwise"] and row["repeat_bitwise"] + for row in distributed_rows + ) + + lines = [ + "# PR #325 ROCm deterministic FFN performance analysis", + "", + "> Operator-only benchmark. No model checkpoint or serving engine was used.", + "", + "## Environment", + "", + "| Item | Value |", + "|---|---|", + ] + for key, value in payload["environment"].items(): + lines.append(f"| {key} | {value} |") + + lines.extend( + ( + "", + "## Methodology", + "", + "- BF16 operator inputs; FFN dimensions are H=4096 and I=12288.", + "- Native GEMM is `torch.matmul`; native communication calls PyTorch's " + "ProcessGroupNCCL directly, which uses RCCL on ROCm.", + "- The native distributed FFN uses the same weights, TP/CP/SP sharding, " + "and collective schedule as the deterministic path.", + f"- Single-GPU timing: {methodology['single_gpu_timing']}; distributed " + f"timing: {methodology['distributed_timing']}.", + f"- {methodology['warmup']} warmups, {methodology['samples']} measured " + f"forward/collective samples, and {methodology['training_samples']} " + "measured forward+backward samples.", + "- `NCCL_IB_DISABLE=1` selects the same intra-node XGMI transport for both " + "collective implementations. Raw median, p95, minimum, and maximum " + "measurements are in `results.json`.", + "", + "Reproduce this report from the repository root:", + "", + "```bash", + "python benchmarks/benchmark_rocm_ffn.py \\", + f" --warmup {methodology['warmup']} \\", + f" --samples {methodology['samples']} \\", + f" --training-samples {methodology['training_samples']} \\", + " --output-dir benchmarks/results/pr325_rocm_mi300x", + "```", + "", + "## Key findings", + "", + f"- The gfx942 deterministic GEMM scalar fallback costs " + f"{ratio_range(gemm_rows)} native latency. This dominates end-to-end FFN " + "overhead.", + f"- The fused deterministic SwiGLU costs {ratio_range(swiglu_rows, 2)} " + "native " + "latency, so it is faster than the unfused PyTorch expression; it is not " + "the bottleneck.", + f"- Deterministic collectives cost {ratio_range(collective_rows)} native " + "RCCL latency across 2/4/8 ranks and 64 KiB/1 MiB/16 MiB per rank.", + f"- Distributed FFN overhead is {ratio_range(forward_rows)} for forward and " + f"{ratio_range(training_rows)} for forward+backward.", + f"- All {len(distributed_rows)} distributed direction/topology cases are " + "train/inference and repeat bitwise consistent: " + f"{'yes' if consistency_rows else 'no'}.", + f"- GEMM relative-L2 error against FP32 is " + f"{min(gemm_deterministic_errors):.3f}-{max(gemm_deterministic_errors):.3f}% " + f"for the deterministic BF16 tree versus " + f"{min(gemm_native_errors):.3f}-{max(gemm_native_errors):.3f}% for native " + "ROCm. The fixed BF16 tree buys topology invariance, not better FP32 " + "proximity.", + f"- Distributed FFN output drift versus native is " + f"{min(distributed_output_errors):.3f}-{max(distributed_output_errors):.3f}% " + "relative-L2. Conversely, the balanced deterministic reduction is closer " + f"to FP32 than native RCCL in {closer_reductions}/{len(reduction_rows)} " + "tested 4/8-rank reduction cases.", + ) + ) + + lines.extend( + ( + "", + "## Single-GPU GEMM", + "", + "| Shape | Native ROCm (ms) | Deterministic (ms) | Overhead | " + "Det rel-L2 vs FP32 | Native rel-L2 vs FP32 |", + "|---|---:|---:|---:|---:|---:|", + ) + ) + for row in gemm_rows: + lines.append( + f"| {row['name']} | {row['native']['median_ms']:.4f} | " + f"{row['deterministic']['median_ms']:.4f} | {row['overhead_ratio']:.1f}× | " + f"{row['deterministic_vs_fp32']['relative_l2']:.3e} | " + f"{row['native_vs_fp32']['relative_l2']:.3e} |" + ) + + lines.extend( + ( + "", + "## Single-GPU SwiGLU", + "", + "| Case | Native PyTorch (ms) | Deterministic fused (ms) | Det/native | " + "Det/native rel-L2 |", + "|---|---:|---:|---:|---:|", + ) + ) + for row in swiglu_rows: + lines.append( + f"| {row['name']} | {row['native']['median_ms']:.4f} | " + f"{row['deterministic']['median_ms']:.4f} | " + f"{row['overhead_ratio']:.2f}x | " + f"{row['deterministic_vs_native']['relative_l2']:.3e} |" + ) + + lines.extend( + ( + "", + "## Single-GPU FFN", + "", + "| Case | Native ROCm (ms) | Deterministic (ms) | Overhead | " + "Output rel-L2 | Max grad rel-L2 |", + "|---|---:|---:|---:|---:|---:|", + ) + ) + for row in ffn_rows: + lines.append( + f"| {row['name']} | {row['native']['median_ms']:.4f} | " + f"{row['deterministic']['median_ms']:.4f} | {row['overhead_ratio']:.1f}× | " + f"{row['deterministic_vs_native']['relative_l2']:.3e} | " + f"{row.get('max_gradient_relative_l2', float('nan')):.3e} |" + ) + + lines.extend( + ( + "", + "## RCCL collectives", + "", + "| Operation | Ranks | Input/rank | Native RCCL (ms) | " + "Deterministic (ms) | Overhead | Det/native rel-L2 | " + "Native/FP32 rel-L2 | Det/FP32 rel-L2 |", + "|---|---:|---:|---:|---:|---:|---:|---:|---:|", + ) + ) + for row in collective_rows: + lines.append( + f"| {row['operation']} | {row['world_size']} | " + f"{row['message_bytes_per_rank'] / _MIB:.4g} MiB | " + f"{row['native']['median_ms']:.4f} | " + f"{row['deterministic']['median_ms']:.4f} | " + f"{row['overhead_ratio']:.1f}× | " + f"{row['deterministic_vs_native']['relative_l2']:.3e} | " + f"{row['native_vs_fp32_relative_l2']:.3e} | " + f"{row['deterministic_vs_fp32_relative_l2']:.3e} |" + ) + + lines.extend( + ( + "", + "## Distributed FFN", + "", + "| Topology | Direction | Native ROCm/RCCL (ms) | " + "Deterministic (ms) | Overhead | Output rel-L2 | Max grad rel-L2 | " + "Train/infer bitwise | Repeat bitwise |", + "|---|---|---:|---:|---:|---:|---:|:---:|:---:|", + ) + ) + for row in distributed_rows: + lines.append( + f"| {row['name']} | {row['direction']} | " + f"{row['native']['median_ms']:.4f} | " + f"{row['deterministic']['median_ms']:.4f} | " + f"{row['overhead_ratio']:.1f}× | " + f"{row['output_relative_l2']:.3e} | " + f"{row.get('max_gradient_relative_l2', float('nan')):.3e} | " + f"{'yes' if row['train_infer_bitwise'] else 'no'} | " + f"{'yes' if row['repeat_bitwise'] else 'no'} |" + ) + + lines.extend( + ( + "", + "## Figures", + "", + "![Single-GPU overhead](single_gpu_overhead.png)", + "", + "![RCCL collective overhead](collective_overhead.png)", + "", + "![Distributed FFN overhead](distributed_ffn_overhead.png)", + "", + "![Accuracy trade-off](accuracy_tradeoff.png)", + "", + ) + ) + (output_directory / "report.md").write_text("\n".join(lines), encoding="utf-8") + + +def _write_figures(payload: dict[str, Any], output_directory: Path) -> None: + import matplotlib + + matplotlib.use("Agg") + import matplotlib.pyplot as plt + from matplotlib.patches import Patch + + plt.style.use("seaborn-v0_8-whitegrid") + + gemm_rows = payload["single_gpu"]["gemm"] + swiglu_rows = payload["single_gpu"]["swiglu"] + ffn_rows = payload["single_gpu"]["ffn"] + labels = ( + [row["name"] for row in gemm_rows] + + [row["name"] for row in swiglu_rows] + + [row["name"] for row in ffn_rows] + ) + ratios = ( + [row["overhead_ratio"] for row in gemm_rows] + + [row["overhead_ratio"] for row in swiglu_rows] + + [row["overhead_ratio"] for row in ffn_rows] + ) + colors = ( + ["#3b82f6"] * len(gemm_rows) + + ["#10b981"] * len(swiglu_rows) + + ["#f97316"] * len(ffn_rows) + ) + figure, axis = plt.subplots(figsize=(18, 7)) + axis.bar(range(len(labels)), ratios, color=colors) + axis.axhline(1.0, color="black", linewidth=1) + axis.set_yscale("log") + axis.set_ylabel("Deterministic / native latency (×, log scale)") + axis.set_title("MI300X single-GPU deterministic overhead") + axis.set_xticks(range(len(labels)), labels, rotation=55, ha="right") + axis.legend( + handles=( + Patch(color="#3b82f6", label="GEMM"), + Patch(color="#10b981", label="SwiGLU"), + Patch(color="#f97316", label="FFN"), + ) + ) + figure.tight_layout() + figure.savefig(output_directory / "single_gpu_overhead.png", dpi=180) + plt.close(figure) + + figure, axes = plt.subplots(1, 3, figsize=(16, 5), sharey=True) + for axis, operation in zip( + axes, ("all_reduce", "all_gather", "reduce_scatter"), strict=True + ): + for world_size in (2, 4, 8): + rows = [ + row + for row in payload["collectives"] + if row["operation"] == operation and row["world_size"] == world_size + ] + axis.plot( + [row["message_bytes_per_rank"] / _MIB for row in rows], + [row["overhead_ratio"] for row in rows], + marker="o", + label=f"{world_size} ranks", + ) + axis.axhline(1.0, color="black", linewidth=1) + axis.set_xscale("log", base=2) + axis.set_yscale("log") + axis.set_title(operation) + axis.set_xlabel("Input per rank (MiB)") + axes[0].set_ylabel("Deterministic / native latency (×, log scale)") + axes[-1].legend() + figure.suptitle("MI300X deterministic collective overhead vs native RCCL") + figure.tight_layout() + figure.savefig(output_directory / "collective_overhead.png", dpi=180) + plt.close(figure) + + rows = payload["distributed_ffn"] + labels = [f"{row['name']}\n{row['direction']}" for row in rows] + figure, axis = plt.subplots(figsize=(16, 6)) + axis.bar( + range(len(rows)), + [row["overhead_ratio"] for row in rows], + color=["#10b981" if row["direction"] == "forward" else "#8b5cf6" for row in rows], + ) + axis.axhline(1.0, color="black", linewidth=1) + axis.set_yscale("log") + axis.set_ylabel("Deterministic / native latency (×, log scale)") + axis.set_title("Qwen3-8B-shaped FFN: native ROCm/RCCL vs deterministic") + axis.set_xticks(range(len(labels)), labels, rotation=55, ha="right") + figure.tight_layout() + figure.savefig(output_directory / "distributed_ffn_overhead.png", dpi=180) + plt.close(figure) + + figure, axis = plt.subplots(figsize=(12, 6)) + names = [row["name"] for row in gemm_rows] + native_errors = [row["native_vs_fp32"]["relative_l2"] for row in gemm_rows] + deterministic_errors = [ + row["deterministic_vs_fp32"]["relative_l2"] for row in gemm_rows + ] + positions = list(range(len(names))) + width = 0.38 + axis.bar( + [position - width / 2 for position in positions], + native_errors, + width, + label="Native ROCm vs FP32", + color="#3b82f6", + ) + axis.bar( + [position + width / 2 for position in positions], + deterministic_errors, + width, + label="Deterministic vs FP32", + color="#ef4444", + ) + axis.set_yscale("log") + axis.set_ylabel("Relative L2 error (log scale)") + axis.set_title("BF16 GEMM numerical error against FP32 reference") + axis.set_xticks(positions, names, rotation=45, ha="right") + axis.legend() + figure.tight_layout() + figure.savefig(output_directory / "accuracy_tradeoff.png", dpi=180) + plt.close(figure) + + +def _environment() -> dict[str, Any]: + properties = torch.cuda.get_device_properties(0) + return { + "gpu": torch.cuda.get_device_name(0), + "gpu_count": torch.cuda.device_count(), + "architecture": properties.gcnArchName, + "torch": torch.__version__, + "hip": torch.version.hip, + "python": os.sys.version.split()[0], + "git_commit": os.popen("git rev-parse HEAD").read().strip(), + "native_gemm": "torch.matmul (ROCm rocBLAS/hipBLASLt dispatch)", + "native_collective": "torch.distributed ProcessGroupNCCL (RCCL on ROCm)", + "NCCL_IB_DISABLE": os.environ.get("NCCL_IB_DISABLE", ""), + } + + +def _validate_environment() -> None: + if getattr(torch.version, "hip", None) is None: + raise RuntimeError("this benchmark requires a ROCm PyTorch build") + if not torch.cuda.is_available() or torch.cuda.device_count() < 8: + raise RuntimeError("this benchmark requires eight visible ROCm GPUs") + if not _EXT_AVAILABLE or _C is None: + raise RuntimeError("the native rl_engine extension is unavailable") + missing = [name for name in _REQUIRED_SYMBOLS if not hasattr(_C, name)] + if missing: + raise RuntimeError(f"the native extension is missing symbols: {missing}") + if not dist.is_available() or not dist.is_nccl_available(): + raise RuntimeError("PyTorch RCCL/ProcessGroupNCCL support is unavailable") + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--output-dir", + type=Path, + default=Path("benchmarks/results/pr325_rocm_mi300x"), + ) + parser.add_argument("--warmup", type=int, default=3) + parser.add_argument("--samples", type=int, default=10) + parser.add_argument("--training-samples", type=int, default=5) + return parser.parse_args() + + +def main() -> None: + args = parse_args() + _validate_environment() + # The host exposes unusable RDMA interfaces. Both native and deterministic + # paths use the same intra-node XGMI transport with IB disabled. + os.environ.setdefault("NCCL_IB_DISABLE", "1") + args.output_dir.mkdir(parents=True, exist_ok=True) + + payload: dict[str, Any] = { + "environment": _environment(), + "methodology": { + "single_gpu_timing": "GPU events, median and p95", + "distributed_timing": "synchronized wall clock, slowest rank per sample", + "warmup": args.warmup, + "samples": args.samples, + "training_samples": args.training_samples, + "operator_only": True, + }, + "single_gpu": _single_gpu_benchmarks( + warmup=args.warmup, + samples=args.samples, + training_samples=args.training_samples, + ), + "collectives": [], + "distributed_ffn": [], + } + torch.cuda.empty_cache() + + for world_size in (2, 4, 8): + result = _run_distributed_world( + world_size, + warmup=args.warmup, + samples=args.samples, + training_samples=args.training_samples, + ) + payload["collectives"].extend(result["collectives"]) + payload["distributed_ffn"].extend(result["distributed_ffn"]) + + (args.output_dir / "results.json").write_text( + json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8" + ) + _write_report(payload, args.output_dir) + _write_figures(payload, args.output_dir) + print(json.dumps({"output_dir": str(args.output_dir), "status": "ok"})) + + +if __name__ == "__main__": + main() diff --git a/benchmarks/results/pr325_rocm_mi300x/accuracy_tradeoff.png b/benchmarks/results/pr325_rocm_mi300x/accuracy_tradeoff.png new file mode 100644 index 0000000000000000000000000000000000000000..e6996416e60515f0b15367ade6b79212df897de9 GIT binary patch literal 93854 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%0Dq?CyN@>Dm`5Utm74>JxW-xb2@c)qVn=@2dcB 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

>HKl5YVZN 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

B+%NE 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 LKb(B<^yU8t1cT8q literal 0 HcmV?d00001 diff --git a/benchmarks/results/pr325_rocm_mi300x/distributed_ffn_overhead.png b/benchmarks/results/pr325_rocm_mi300x/distributed_ffn_overhead.png new file mode 100644 index 0000000000000000000000000000000000000000..c10349a3240588a2556634685695031ed8939ab2 GIT binary patch literal 92815 zcmeFa2UL}3w>63yE0!b{VkIhyQX_~;M-!qOq=*#hDlK%SO2-)E7m27F0qLk9(xppR z3?f}o1f+>Hr7FGi&$Tt5eBU|azxR&&pL55!r&CoO3<=p{#g##j*{{ z*x1-sFpm7B!p6of!^Za2fhCLZlRyXE9rz+Hic7mXDqDkEKE;- z?_gwOYieyJEU@PX0a3p1f3dSWV=E>oX!*})2w2;g2=4s(g(lu*>6s&%wrp%06Y0Ns zdK<29Vw=at#`x)=>bc;aM#mef!{gE)MpYs&e}DVewQKp3JWnSk8T90iCjPM@dylNo z&C@UMC5?Xj{5x@;U%z))V-bG((K=O`Zz32b=clJ1)s6R-^d-+1ip$gMJX2BDP}wk9 zR%X(-`Hfqcwu-vC`Z`>|=ZB|QxLy+b-{0ZuJ^p#WeEBxK;%iU3_s@^6<^S_bw*S^a zc*EWPE4#pvD8-Pf=;Kj;ZW2wdZJ+vOll{wM7f09TUA?~j@VbtQg&aD{JvMAH!(Fk7 z>qazc^js{HO2--Xrcta{^`yQ~lpagp;?#D%pmXNw_N!BG>b0+#C+4OrSH>phY2l@8 zY~jCbSd&fD9BwuK;qj^$8P?4?10}rU1Eqq(rwV@KODPjFeQ{UemA=QcMgH_ion=O2 z)q}IGr~R{DZV-2{(DRrcUcOmuZ-4HnUf#?^_tD@3dyd~d%D_uf@HQr`SN2ylx%7u5 z=w=Iy^eTl(Nh(Qv{ApseKkU@w-;D}>TgqS>`RnfMj!RKYZ+4&T$!K;rtxGma>wYlu z+T6C$zD6xO2hXIRz0$EQx5#Yw6aDaT!3(@!;f&VUN71f(cLrXYCssSVc21_ApDrcDUaM#+Aj~lIX&W_-EBWKz!{kT$;%Q|;h-J$l>r3Tl*az@9+evg^KFb&bX zhzPFoKoNO*@4l>V;~HJZa)Im~=Fe9)R67T~h*DB&&T|t!^X6gBWMB4rX?NG1N}<6! z6#^sdyI*NyZeGM|XY?c$ZP9e7Gcr%B_+vHqUHyD_r*>bBWknx$AHN&nG}vKUpKi&T z-?VD=I?P5@s_6@!nqwbRCa@sPr=3qE>$weA7t9!7{^c*N+!-mTBf8}A6p!A&z%x~-CojEn;CX?KqXFe{~JC6pwGRbOeEgy>)%G;Pa8IK~>X z`}4%Y3!8EmT>95U9pM@X%`OojJ zhf2B_w>`bSe!rEDqG63yJzBN;wB**DqZ!`rYw68D8aEqMRz z)?=mH?7fbigJl82?A$9?a7syFb5_c7=-zl0uWf>bo^V$8&f%*S#oS>!=bF2!WBsw- zjDjrFi!bvg+^kD6>GTrJdn#Nh;j>D5>W9_bie)?eb(pt)ywt&z7tlP((Rzu~{eZ_* zD<}J-E?l8;cYKDTzkn{!=EUDuZVsHcV38rFa=pa4GZmtp!4i`_DPCiW{O*;KqdFxe zB`PW^%*~DsNhNy_4l49#2K)=AlarH=2JYS6pEIZ!dhYEXbo-ocL&s?LB|iSOy1LH= zALBPzA)ffGT!f*nY2-_zqG=wVRu!WbOHZfUK^_TwbYXE+YU*A|=b@*`r2;{iZ?`;q zZ_Hp+sI%Gc%h#)%vk0+&RlKj>!lznYo4-^b+k$58*qxu-+x_(`T>5kUkz(4jx)Uag z9Zz)@nKSy#N18omBfDJeCf-MBWCAR)d4_FZVUX~jn_UMLyv6$-{JB|tA0zqWlZ~Ai zq3Gnv7TmaxOJ63pzpjI(oV>j43x)lWnkmMj<840vc6IV;KdzG8n?Kbq7~9+B+IIc0 zaqaz6qKLqh=5mm2oVuc;)@9xq8LrXSUm|Udm7Iy7jr>=tx`DN`^AU?^qulWG>p;pW zU$MVIxz)J_Y02!db5yX6oIuWp0*Rq#Kknw`ElsP@<7HEbx9@!|g3K|#E&k5kaZPQ7 zz`eyo?_UTTmE2$jmvU?Olq21(QPElBQy#OU9-^~TgDmiytKvnmkK;L6-%zmW7i#Wr!dmq?FBc3-kP&)MP`F0w>&W+mY>V7GeQsT6}n1)Ci<(xAgF7@E1 z)k6QWduqWrEY|_s8=c@SBGS3}RKeZGe^4Y`bND-;K11+l}7y|iI14s;Z=PT>&YjkZtJX+j2GudC+Qh?$A=ha)EK+Vlr=duixTwVhr;y2$u~Q=fr{3eW=}pevJ?ZsUX@Myi zQx$;6yuX2$R+^cwfNoaXZ>trb{=CsrwbfP{i&|o|!PW_BcK~~-6IWUsENV;f)2{2~ zZt>pK<0~aTJUldZpC>VI!i*L)*Pz(1l=KLT)9NvN^YHw7VdJBL`z!-1Lc}|1TOu#3 z#g3Z3iqmugv>PZBu3Xa;1sq@!>8oDyO4~YQ`&9{{&0=;Z-Z)bTC#2vuIZ}>I5Xxk- zb|0ZU8-&1DV~yi`erb4cR#9^J<WW8R`e-jf6|vf zJA+uNWHZ|6*y*dGSA27i0hWl5U0;Lf;>~u-S&sdB2M$K^5VoR3rlId9^7!`^rGRGv z0m3GfK{YMYs*{IbX?NoGl#sMzUENXQ@HBe#rqy(~@G<)GCi@QUZ$o+0(J4La#54rt zETugr*NSbMzk`7&Bi(lIj;uo$?RS2@Qu26}bg*I5(w)GW(#eQ+ zf@h|KERq?Dm?oXGg=-m1^MuTu7|co6M-AFmnUVLKo6i<)wk=r7{c=KtFQdUm&0R3h zWhz+Q(TYkg38WSpEg@72fUH}QnM`Pg_gXjQd}v5ADC$66R8HfBL>LK}A0qBp@y+2) z$GT&;<>2EluC`vck1eFE`;BfNLTwNWZSqdP${c&^m0x3hoq#WRb|jSGTBHxjenL^*x{q z6@i5Jg-t4e3oI!on;;&QuN3c5wro_J-Z>7?>5l?MaKWPGPiyo&LQvDL^A=UR!ii#l z=A3SLe4;z?#cf$Hi~EljiN25U;c@e4I&qITIySql-)C`xDks1NDZo58TCQeSMT&F! z2k#xbQvp7PX%#j7f?VOekZpyhYbxBu8~Hsu;C_DX%UNpj%n zb|(NRAz(lxb7RV1fcpL`H;Wk}@RnkO`C`?SXEfQ++V6Df$xcj)sZkHXy+$GPIE~bq zu;<&FRECCNG$W2jDb^v%40!2J-7Z=E10v{2Q*O2u_^KLv`rc_;!aT8YD&3tFSSa-h zyNvYYU>XUoCj&Wi2h{YQsaDe{=g@b(j$M;h(z$BmzPPX56+0F#i&-X<4;+FGq{vjA z44W0q`Eba6vcB0E+tznW*j`f=lzTTYNc(4JM)PgQ+xGm%xIgiCkBE>+C^f2(NPq^GtL{7LJk!M4F>Ez1bS$L=DmyTyI1rNQonLYlL#eck!RTW%ts zZV&UAaiU)YpD9=>5_&}0=klqfu3xp;yRRSKQcOkYct=I}!3#pD50`)UL%7Pr2e-f3 z{<9&lF>lXt-oOKAPw!L=zDczoiee1`WZoViTd(-OF1!9FNva2pv2Li)IzR87b^i1| znoy=w$WZJu4tEUA_;8{}2II$>1UM?I#y^*x&X z@5^A_mPbd0YQ1}^)7N@cx}sV`KLiLyjIP^H*P(9tdLgd-iRwh2kQ{{ndwJN_>&5JT zaUTq7<~tMA-kdnnTOWm7&#voISZUHx7BI-~frLasgln*)>Ft<1#T8V_3QVGoL>wmc z0x=0vzVn|^;eUmeWqW~jYF}fv#xiNa3WJ$nb?mFvG655gtE=y8-WQ58e-lD!+Ki4@ zT3En7OD*@=$!3kZ_Gy$ICD74rERjunV>Yn1n{}JGu&?LSFb&c_W9?fBoKH zlv`#H7AJEWeUhX=txqs1}OUu_Y zQShiO``*n_M{V9a8iBZ!iW0&c_fI`0KJYyt&+AlEA5cGSnD27%AHE329r#r#D#Shd zi=XsQ5als5J!t|UpfuXom{KLjOH`fH+dsIM+0y_3rdJ+vd@>D`V1v}k(I@EreRU-m zE1Gadhkar;B35VjUlIs(Q^44QU-fv4cHES0vO;aYZ0k+_^xE4``cl%)wp`>`_p5Sj ze7Y9WRVXe|HZ0QXjH40jsk)}p8?-f%Pgba^R9ZEb0J`A5@ znGDo!cyX=zQ@|);!>88>m;^|m$X3Ygv;N9vK`X;51S`9Pwi9n+ z4ihDj5mtvN#%2&DiAkPJ2a26A!zRWLjAWF^oxqyG*4p&ac)jD4>T$zuV6iI2`*V)J zHw=tHaU1pZmL`)hw+`(Yz>Kyx7gh-bw>?iYuj#q}c%>=WN(2fY>@PtI{*<~<%Wegy zQwk`j7puilh}BA{tYF$#T`RieY+}xUT+7I)q`-cwh6C81E(AjhvUnDSgH0PQaLK@R zndAh&>Mfq!n_h2>>UGv4XLr#0HiMZj)ZM(l(ukNZ9> z`O$5bu`%}QB4PgO1W%|G0J+uyuBQxHNV_#@7VuxNVWzKJC%9-Tu)(3;@}iFu)fNa6 z^!_D6rF=g4{PstSIm;wR8+?eqKHshNa=I+kr7r-b*M4ku!>vzUpR6}A1e+3_8loPr zrIsZPR&|qO!&!neOfGP$X2hq)Wp)HoRVsx*MIkZFZA5eH2Ny)$ikhW)w?Wu+VqwVT zIuF~tIluU>yuW}c(8TYn0FaBFh{{Jr>9^OS_6H&}_tl=fP!=M-p9-GOY;HSZ*U_2; z-4}>&5&%>0L4=MVWKv~MuzSn7H|Hq@uLnU(`F&hbMf)PnS=6>`{7?hNf4$}$l`7dc+?-@i`Y7xxzP9y8 zA#AH06g3oEBhM!0j%YER&Ug3!{+3wLsXoX2QY`6Y@WV9dfr%U6(So~kRZ5IN05M_g z0uNYRI*O%OH(kt1$?m9NCO}P!N_Z!B4Q-833dj^Ch`IrlQa!fi$|g}EyhL6|kZnJ4 zSRjvSAh+JXKRYuisB-wR4RHpGmVbAR=vRW?72^HDAONH(;C9s{h5@)l0L88swK3fK zX9{R{{+H>-6~O`YbMVzz1lmk4ey!A}btYlCM-oqAksu|1ri+}1-W}_0?>l^DL)yb( zY+zmhd~2%G)VdBhJv+F#ok(ar={hEv5V^<1i?9xt85#qijI7sv@9@RB52cz8#EJDH zW~x*P1UtMo6?rv;1r~u+#@d6x9UNPl5mKmR?VvfP!V_flP;dQyh%MTYok{^hJBUX@ zt`9}2-+@vhtlx$1sGaI@2p~a%`BOq3C}nTyv`nwt3B0Kr2poL^ zsP9rI@#8Z<(luj&?tGM$ph-{}E8pLgO9O8N-hZXcX>fb9{s^z_{`pfzRF$(LllS%JMhygG8?T(%*I4E3^Ww24 za-OUVX+Kzky<&vL6q9O!!d7&!OqhsDK)+qYZ<2B}o^DT^+Fz@c$`*6FUZXfl@iBfu zJ$pAsl2>OqoX~)kb=S*i;uF|MdHXoc%&}^Be-#d_pkiA0=FtTX)5f%8?kZJSaw_jX z(&|9;R{~t}0qwYrZXBc)WrHY{nvUF&*SsWL-5MMWact5wV4DDkR{^@k$ME_5XJ8g- z!j_H3cID(gXwIi9&z(~>qdZa#1$Huqr=7?n0&e)vK2OFZlT`?IZx(kbTeQ(a`9%7I ztK-$<1S`N*aWjZvLoJ$DRXh(Rs0QWDO((eu#FU92A z9FZkDQ(f1-dJ2J{0>9Kb=Sp=fMJkf3D1Bllu$Tj&&JzMz?{3R&?LmJ10TXZr#r>V- zTO|Vd;^iM4_`0QXXETW`@wIm_7SYN*yt(z$oV&-|{*SJV$ zz?>uf~i|uaIksBxt+zB&`=Tv-KQsr!0lj{_OCzlc!lkwg&b?TT*0rHx$0_L zB*~JLGoH2nRjh^}(W@=)PGi|SDMwIoUSO0#G)f26Okf6*Uz^3Y18MX8CbUisQIskg zs+i=V>j*pa)RN}O655)lI`&h6DrD34lw?aFnZpCI`qMG$-MRQNY2k7n`x?$Xrdo>j z?FK;QcVb$5o~Hi*(dXEMz0-p3AHB>jC^Lu^NJYu{WH=t#5F39+#pwGs02n^IhS5LQb63rkFKPM93ttMpUb|^ac*0>8emhCAj<0#P6A=+oWL%mQsZRuWh z5$XI%69`jjF;T#46tqzM8BvCkb$0X8#)d;(Tcf%R!w!~i*`p36>FLxT4)d5*$Ec;X zblT9^6YS&~RFsJ}lk}=5+`ZTQ6)qoiX-!4?MrDDDiX zDbGCp;C?#K7XSSE;`F!EY8tx3E{WOufR=;C3o46qT3=w!0}Pw2JqgYrjK>Y!Oaf`P zPVpSgRmFymv`r1oQl^z0OmM?C=?Du&tfb+NV*7A8#M3AXVCmF>iO z^NcD{emq+fB7L+^n8;x1s;Ho!lD29NiV{${zoU8!c(JQ}+8YQDDb$ZGI1 zJKRmqo}d@kZk-hoV&y^m^|x^=HX^JAX9!HBAtNY_fFr_zkA7_@a%lTi5%opziG8g>qLSFsa z#JIS)uW!_Y!Q%LCUoBW;_D7!JTr-~}9p-eiODk2^woHplt&)SQU^$067FY^oIHNmP z_G!JdSB+GQRTo9XN(N@o5WnjIB^&j(FvhDexg30A6hgz`!Y3R*7s`8jK$!5#$wLC= zyRtzf#zu3nqntft*J1BX#P13WIh2Sy5`{s;`4t1Csk#l)VL;FcU;hMFE@Rm|f1CDO z?WpqH&d+PPy!Cm1#Uw(96w(H2MiWa~;N7Co9?csnt`-w{xMXQQlmYf?k+VeLq71tU zarFMz&vbOss@Lem*Pb8tQIgVp*Q?s|(@^MlR58&AOZxMp{|R&FMzZ8AlO|+WTkP zeJiCVSlS*SYW7!C;1P7%{;4;JQ!1u+wL`uK-uVO-1)4A9J2FY~T@pWH;XE(KBIw^vCHDN~sOuE*r@iv7Wf7fxEf>_|D< zv9JpTO+Cb@^iTCFl}Y4^(svtHgD|VLWUqS-VOA^#vy3{_!e&3#wWrsf_B!Ng|L)nX zi)X4Jj}4N-6~OU*TyKt2$ExpEY!*wc8ZjG437h7_XqBSG;&_nTk0n`gQ}CA)#|qEr z*vABhHLIx=wFMGAKr{f83woZ>t#0Ea{&&Cqad|W8C-r7UZrHd){t2J^@WvHIY=DH5 zP1^Z{euvT7TQC@1)!O;A)~q27t^& zNt9}{pH`iE%aQ*SVCY)04|gXas>F>07@uVt^Xfpyc6PtX0S;87N|K6qF2dQ`t;JHs zIjb+}fwVF6=P;K(zNJd3qt~CqZYptX<1kDI@eX>9@2lEfLLR1vw<;I*_f@)&q-b4< zE$@FX8y}lqRMcewhY9T(Qk$u076m;+v2Z%P=t>uyYe^qAo;|3+1JT(tOOfSpxu;Sn zV9LJwt0Ns3_mqlQH@W7u!$(#Mlnhd2M^vexzup!LfmI@o-LJ6nza9pjrZ?O%K6~&z z=nK=lgeV|io`$~q4C{%JUhVEIjv;4%B<2nN{+BdL1*7z|5lQ7HM|x8bf1_MR`^NKU zC-awYI`9KcWZ-^ly(Kz+8^Qh29_pRQ+qgHcD<;+k)`l-ySWK$xg%$gr>SG5`Y#Fa_ zp7En<2i$@cG1(is^#CbiSBP+;jwPbNrr~VSKY1R=t{hn&+{L8QK@!VOIAq=iLysh$gak68!uYk*%fO2UBbH!d)1zOWy1z4Rn$JhIF4tzDt(aA+Kx)^r z6lC1WcCx4RvoPV#Ti3+e=t(e5Ja)1k(3$KI>)SN+T?*J&;Rd#2g<}+74 zoqZrh;}B~})tLC~gYXrb$O8zv_^^h`VE6#loM*79*trXr!>t3aO4sP?8OWLIM4zhf zc_t0&^3N@jVuWa^geE?R$l#qp7Alr(wr4s0^Rq)Pk8(Inv#T6`kotB?M|p|;L0eG< zk=9&{3yW5m4NqHOvA}GTzot(qL`+2A^`k7QFn_|jM6A{pKU;qfVnFe9U%`sG_nm*o;#p}f3yOH&06UUII<@V7f8Ey?A!j zKJLLol~gYxis~-0^jplSfmliO6HD@=SdQ6OgCcU`ot?ItO!Dcc-IH3+B4ar;Y90md z1)~RYym=7ir39GFrMTqNn6A(Z%H3=8fi zF>{EJ3c#?-!fG%}0Z1y`jI@wjrPVv9RGZR78L0NvALJhBbSoV8(|?`2Gj08#feqYz z?UDX^a#*|xfc`AQnMByS>f3!mR$1@w5<|%7Shxz*Kq<*On((>2z}hU>^9ICG2_RGm zSK3NB!5GTW9Qk9iR$xGn-uz)JE!W6|Joxg?wK%99ERkJdCiw1w@VFW+Hgr0~i;QGb-<`w%A?iVb(SdUd) zII3lBS?%C0;N5EB#O90*ssMJK<3Jv;qFN~5SXCSG>At#L-m7jGHc+3p}OiM7|A&|;;!v`0)<{JNO)4tE-uW$DW zFsL!AIW`9^y$#l0&2LsKn=ZR;k$tzzebF7=7L^KzhhoIZ`}PuuTB_TK^)0>HcW~&|5t*%iwbe4>Puv}i^+isIduGq zZ|oT747uWH9eE_a_Fn|n-A2rz=O!5`N&kdk$C2ez4;d6_8O%`flQ*&q27|DIEA#;d zlZemj^Pe$T%sYq)1tw|dUa1LOgf@-8Dc9%Z`1-eus%gu>=B}i zY?GcE3HRVwG3S{mNoZzxiqv!VPXGGyWp%br;TfC4OueM;UXV#aRP?^8pH8^k9Rks9 zeo>8a+0|lL_uNgQw}Q>Fuzp}2?ncIp6N9B4mdd>J=W~PqQY^LcDIo_ z?u;g9bEeay;sLfHP^08n1@QS+AYV>Kc5UY%l8PU>C6=n{h`aP89j2jfz(^B0Zvzgy z19fh&wGNOW@d1aThPVFsyK6t&5N>!`27;Q3sU~EgW!xpI67Ds!R9zx1`$VWHyPu+x zk0e-%8&u3^wlU>tB+DF6Yv46i`5v=egH8F!Yywpdu@gD5>`Mj9vHrt|TqPxwNIprFlxx@x~ zR|kCkPf<7o;i}u97nYHj3}K2audHAQ)j(D3n=@x)&sB#6cJLw=PklGW@io4N%e8N< zwV{1H>O2FyBn01g!8FU*dA7Z!9j+N;fc=Y}gL1s_HvmH{^Uh)ylv9#xWtN0Ql&bYG z4}g*FSDUPgIQ>Isw*M{<+#CT<^~tE)m;KKre)s1+#lr8a-Y!X3?-@Ih9*l-F zKH~KUTjmDw%GqnLV9Y2e-b*aqt!f4%Whl{H>mns>5 z1?<`I=tClwPghA^g!+*Yk2Yuwz{SweUs*{<{ev`JB}dD|5Z?aeRby43|tz6 zD7w}?Nka<*fc8!6TtGd&t?$Um4*e$MRhl3_hMZ@iC0u)%7xgp>pA8~Gr#<|*R=WFg zOZ!C;2=@iOoC7uurTiH>_flSIneSjwhLQ6>IGe}g;K~W&=ZXQ08d*o`V`9}&74_uL&M=r% zKBAyMbDdY~9QJ)oY=Ty6Ev(FZXWZIbVh0qby-Fd|`WWgJb%D&=8NDfnPhZcMMb**5 z(F*zHJ{Lf_1koH!LqN}qiZ#vl*q$7RM#)t{5|5U3E5eUJk5>%>v<1`xU%w2CIw7il zL0Q(!WWB@gR$vlv7U>Jizp9VgccH3|CrtLmM=F z3p2x_&!u@U?3FLg2zqJ7Sd&_?9G&8j^{xQ_e zvs_Bbporc?{rIUkc?B&+Ye_tLvB^*opEYlkybFzv`Yki?iX7{$z1$eI7~mD5hATjt ztr1Wp4&aEvL=KAiT4JK_feoCll|-3x4Ho3Ub@FC@x87@VK)}SO#N-1H#=d;VtB9#w z`HqYC%$CI}BDoO8XmM8vIcXky`a2Vll{#(1{70N_?k-;SYMwLkFAWL1b;yybR$rdR zLtb`(7Oma^OzoPES=tK#8|qqmTTTW;&Lgc+%X&1MnqLmpRA4ewpD5Q-RC`t*-A!yV z;Y0>Y9E9glHsO~R)!<4I`vY!JD#_0wh~>g9cEizEPX}-=@zAAC5O-w17yL>AltgbF z(oMBg#_0#6f#wOCarXQx;c7H&aYGQETsAp-S z6nXfqamD18Dwt-+igdBp-;BM0&YoFS=Qx-$MbVYuQzq^gf_yiqD|>4vGO0lDF6E{Amr{--#rE1Qyr@y*; zXt;7(W1$!3^&34`lQ=b)J(&8o_`FwZ32(b@HM*pNi1hTzkwQi}p|zAnI*LpbNzYuz zO66iuw+a=<)ebd5url_69-wxci+x7q@uVg#vloONko z&VcVRK`5y9CSx`EDYybSc4^*tb54QBK`%jIYyuXf4lwj%P2G8ro@0A@Cg4+04dehZ z)Zl91ec{y5Lpa}sBW-$h&T!gAvq@P@Jr|}u~ER>Q*G^Q+W~Q&5hmqkHk{@D zr#f7sn^0jhm|)(r)K5L8>L*0ZUJee|b>=d*$FORNLGrydLxGRP&v>ye|HZj1-91P1 z1nP)#d~N`j6WC@OEbevQ8{5w(cJ%;%U971COE=YP?Gd}@zLdd}KS_3X8Yt%GI6f?5 z4(62XnsDf~f>74>ZDj>-MKkKP^2Reah%Z2r6em8r#TMq41>`$W7j^JeQ!ggkpkSJs z3aI1ET;h*AsD-FEj$lvZ?ZF<5t@?o{0)728gag;ApV(TQ)67TyxyW`Zw{8V}{B7xK z8-!i*Mv6GtZAQ^OL+THxg~XSC9pODr8+L<;*$uAD_jiM0f{Umlf$WV77sYXO zy5Bv0asU1p?`O)Hlw0e!>r|h$PnvqH5 z8mD-?voRq&(~I2|=DmZLZ4Z$@?$E4^5kAoT;O+x|jWCT3ktx)ZNemuYm6)pk?`azc8Z%ptwZ*{I^PjEq1Fu+#{Nx}BK?h_wUOOXf+f&rv!jt`*`VioYAe#RYhib_i3XO)vDxf}L53Boq zqt#8IHp5%`Ma0{pt4|Wtk`pm97OBsFMjw${GJ0wZVJIUvA$ejCeLn#4C;DZb!`au= ze+c;P3W|dIIcTAFkm;RlOMkm1vFkFaTaC2;`0O)QAcLr*k(MCK97YxcByb~8t4@e0 z%M!7Z9ZIdTd-pXD0)+=+#-wOPkQEe!V0q+cb;81ssAkhxA)i&8Y-AX?1O+*oOKO}W6C|zd z9waYn>{~YJL!vTjRIPhj^gmQH+eH;UErpe$ZP#c>souxB45N@j^&)LG z>b=4!lu=Fc*#IV@S9tQQI6MX~V8S6Qne^7~( z$c+>vH<+}`*Mb(dIkca4iQzxXHdD7otp-ONSOV`}b`#{nUZjJLwju(^uKs0d=} z!Rt=`XoDF*+(6-q1KVjw07Lsi8QM*yF8UT@3FVOZNtwVr=Ktz5n z>S_Z|NWw7^3(s$9gbhu-5$@{7p>a?>m;=vI9d-`&%o?L$Rsx-NdlzGTlgyG?*UQRN#5w}9&huk9w zgB_rQlz>jyHKthv{7;`-OsVUITydcMM#=C47Lo*H_N{mN&9GOgJ!2DyRQBbSI~f^P zjXb&|xmj!j#39fg;4XwhEkbGGN_P`h1NGFj!68@vk8idM5fl-Z*pGX77Wv`QUJyLw z>?N09?B?Teo0622`Q}&lW%K?an}i4e81J_@GNyZqXt{P&zwv6dw;lVN;JO-}U(}1i z%LJm}c&{?rJ{XNG3d_~KbOT-RH{N1h_og6F>Akb$e@b3I>LsC|Kn6&JnlcV9bF{d# zcx)JJqV3rxsGcJGk@Qr{DsmT-h*h!Q7}H;g2&304_6q&W)YXc%M_ZP!5gPiv^dJi% z!IyM><)i0f)#F)ada^*Fx}chATp%(JyORu3m1LIG%FW}v1Dlrs(2ougr>Fgsk5Ka% zv3{&BD`aMH9GiXpYOp^|g3tb(<h_^h9BWUm6o|U-qEwwBNG3W0 zfLg5%ok`Wsuws|kg8twLDR8dT<4Dh@{!R3Z-g9upig>Y|{oYkM2P45(Ed8u=4yWD(NZ>`#>pRXQ{uWW=Qs z37;ZQ604gcmI>j=>Y2hB8OkMGEU`JZX2NYVf-pf0>Mf(-OelvMuL}k`%7Z$Q+MZJ7 zPIeXQj-U<-tR>0n1Y1-+#iuT9_CukQRnkt3FbEPVSqM5-P*x^4Zq50u+w1tXs7LHx zdc9*NxL(tFiRVI*#I0{F0I3IH*oN>S$1E6iIH+6i-?nF#>|IDLHYnzeVFY^*wHCQe z&9n@yacK|P?2^YugsH2S=7V%l414UFbfpfrPM(AecreJsXM>#8fvG74f*t@W)989I ztqZX=_G8-plWRwX!4kzMZKoc{Q1G?Rd2Yv{U)X??p@u#=Q`7gZ`E^j0^?RGMV^T0Y zcVV+&!8U|TGErB%H+%fUjZR77Tl%^GpC%Fj*#7qw8~spi@+?@qvWz6ArK@+UcIliz zLo#vtWR4roLIfC;d(_c&=qwQrV)k9COMa+HU;P@zPcXff=tU~M5G9PK#y(Ov2$Zo< zYS%&RE+x#o*`anTx>(R}+pIwcLEyBDHf$3pJvlxk0h15}D0dy4Pb4g*tTyIId4Cc= z+3k0a2GTz$b+L;;y5*)q9i>Mm+T>Y~4z9H@*b3orpoTIm1rxxH3UvA1z{|vmvENpc zkF`&3G(sW+5b4`N=IPVv1l0P59E%?DAF*`;snWz;Hf^)EKDZCfSJWq#36sPCTyHER zHiZXhhr2O8ZY!myK9H%Fpio|o^C)lvb=y&^HPME+Bed(XI>*qy^5CIj27@fFEZY?g z7-|eLJ*-Y`*z}B`g61-Q4$#N|O6iv)MI>Z@dtjDuWC`TiF+SR0nC z0!cg=a2goE1nL32hHb?E(xq^=2CGQ|RUZpNlNAB49|uemLYg3BE7?C_1HFd8%?l%r z0o*_sC6;pe)r^QC`+6nf z(HeP1-PoZDiT(E2;B= z(lqt#W3&0iuu*Ft+x>IZyr0UztB(O$!id9V2q6$|0s&&5wVH=bIfKq$U{IHZ%Gi2( zjeFZy;RI?5JFv+s==>HgD$VJvg`=SonNQW`u}M3S`ih;E%T)|aquORhFZATpx^S9< z{xx;(Wum?`)rGVzNZw=!VF*bGmrYpCHns;4Q5RFB-Xp|%;f~MvDUMbSu~)T5^m9C< zRfaF?e)=ct|1y@o;O~9cW-s~jL(kXG=FvePpC9*xS=ayhJ5RAs{Nw+DU((q_>%wUM zsCSfb0KnvFfAYb7dOTEmNWC=J%><7rZm!Cc#EB%=sTmOIFaQ)4P_dUTP4?%9^j17y zXIuR@o-^P4?QlfOj6@JF6j#W;I(ID^^xjb(eCIomeS2-aPyf(=qN+@E&Oa|d$}wOF&wZXd59?SG!~`7iqPML+ zHshysh?9Rm?tk~mFZlU;``=lT<>&8|P5$SXZ2#X30+B>zgV@OJKx8arj5?5_8@b{D zr2T>KGi%$4Nc!}6sB&=eyU4#tkVbUpBYQm=RD*3wb`#QJwdR9H<#BNO`xOX6s?X** z?>_tT*kLL|6v$&F=|BfC0C<#Bw*zd*YZGO@yx_#LcWk*g-c?1)!xzh>Py%FROWrp$ z+Hpj)V#cRupKzvUZbXL+llp>X6Ml=VwwV?Xa9CPc-CulKLwU_=hunL$1ol2XWR5M7 z(f9%F5UfK~h?56g>I5)iHU4vn_NKnD0W~CeW-~TkG44J9>DCBD6t&lp7(`xf&@pYU zx}oM&p-W7CcwG0(oh!+x>IH_nzpQyrPWE~4mXWFx43x$`J%v2fPW>P#ZkSvYr;%$1 zkTE*|W6I(Czn*?96mdRzi$B6Mgx_^+J$_Ul+js7jJ5o> z+6Fl8E`WTRa}%9*0Z)S=#8oLVc1Kr)guNXs=V z@)g_&OEduxTCgpGLIdI**TEE=&2+5*fionAF`3R>*v5 ztvmv>W+T~#kV5^r)}uKSM-K@#+X_PC*IFDN1x^nzI7Qvyd{(hz&bge?{}|RO=Kse` zFz0!Edh?%oJt93lBM2oz?}N*wJW|{Ytl6Y7_Ag1xlXE>%)GgErQNXK(0vC2fHv1GN zcy4?5I?X&ueyn)6G<&5>CDV|VY395?KK$P@&A+7~r9v`6qdkK!skd7DwD!a|u(W8l zjKJ3uyIJF`W?|=-5n@Z*j)?;Lw( zqT&_If!|N2U!MBm&NjRk)f%YS7)SY2qi>8$QgWzeV+Y?*(St^1OW`^n4va91|66ocNK=Yw5mbW#rY)7(nnDf z-1!BIcQUAB0Une#YC>eK$2vN^p~q`(p!j1^p}K$Cy1!x(!@OxlRkLKgU+@4{P?ha2gU)O-L2%XBD#$5 zEcMT!x#1cyjjTQ;NG{Z)Uu*Q`l4L@5uuX5q=IYrdnU9lDSZ)5Ky?8~>*|Fg|xu4+P z=g(8tW|h;Qzmo~s$~so!^S3Y8|NrQh2oF$Je&ws_e|y?rS!X(w&takLo>Mhmmv#R+ zi1J%E6O8`+_&*3k|BKM=|GX{Re_7@5-!is$4t_c#_f6EPOm_~B?BCvYjT$EL?z+4* zTTiuzdWWe*TTgZ!&qz<@aOLk=KVoA`I}SYY`QP;ArQiP!o&QWVo=oFF<(<3ujBT2N zi~$|@z{J^xEedm1zs$G)y81sAc%MJy|IIj~2=ly*lHHH`!ck#Sd##ZB)EE_+5KiQv zAiRKNKum(B!4;9qx;!W%PtQu2IVZ{QVh%I8D%+#RCn|fNM|?qrY05)vc92+ztDtrb zVxeI5TUH8ri^&Da#y6B$0#+jc*nPg`bFzo@R#|qL%FhN~-h5e0t=`1`{b2`1Y)Y$~XC3mI7;L%WsEab~a;wZuCuGiti5QMH!^{wj{ zD9rYdsd|HLh)(<yUbUWy&wR|YC`fV?wz=38|cN6;G#6)&$k8nFzxC4 z1x2tG(tE)-%RH_qYIHqY1VY7L@-2~CNJd`tv+5mPJLk^i@7(?>94E<13%(lmy>Y{k zjB;_^u$2A%@RR!Y(*KkFZj0F@k(P z)BsOsgi-Ujns*~g1s^WpRz2p9IpZXo{_?Bv$>DB)C`40eSXaPwm~YAk)ksVr9Tenu z^z7dsf!k9#6}?nu6`BO-SU{+i>kgz7V~F-VI;D1pGK=H+^!)p&C(PzQLkS=U;~Y7w zwXTHiG58tFX=;JSoQS}u;1|d?1d~A+Sc&SG*g@QTFb3NYo@=f7zF&riP2LMoCR_&} zOFr4VSS{4uWWLFT)((U~aQ@@p#(bhb%+hu8y}Wb}ogH>bu3fvP@HbsS9*3oLWgmP} zUfOvQp@5@x{IEX+NZRl)*))2Y%vCt;iS;ID^M)TQ88`+Wy6Cqo zgX!lB8(XT0C5tUkis~~2-Nt*N${r;V1tf9=wl68~V6vL&h)Z|^p-YoIepzSF-?s)n zB7#WKb~1~RenM%2K9O}QUB|@`kOEDl-BKK-lM6t4ib4vuL`*o=7Bgowc9>$Pk%g%xk6r1JJK1vS>?AtF6Zxbi30gKcgMyfx0crMhvN5P{ z&D$b#)@)&Qc&O@+2jkRlVo7bUYp4x zjX!<q*;qj17glSm{i0(B&;<6MxtApB)x=KPg`UB6=pbVH2% zGBFkqz-qf{ zaIh*ZE@T1yH?@>$>5Ot*Y6{>0-}$ajFYs)i(ADYr_Hry$<>9+__BbC)lE<$+<@^Fy zK7-51fut`?@sM058zr5eWD&y$)Y`IwOw3f)a$Z=o<`>hgbm&`H$ zNs_@}D=?{1h<%d_h;cgoiIm7yx^pJr{uF zvt!cvH*|uCEfh@35|p4L+kp;Ro}6JZ!qKUjzes{WIjFiv{S; zn&yH+KAp@-XGF)Ld8$xg?U#?;^((#F3cj66L@BjTYRIQwdqy7p_vI#UwD?^N`Ksv9 zDB49Zmq$RvEfip7%}=j8Q9!vGF~=5!0eNaF5XE&(>xjxE`xtJ9Mb*(?Y< zU}Ebx;x{B}VuUUhfsSLM3yMsDV18|)anof?fjQ*Lu4Kw?4dj@Df8%>PNQqp7T*cH! z1_)pWeXyz)z|IK%UQN?T-^>5J*bm#&{&VExx=LPQ@jLKOQn&^d27#5jGaXVi1P)3s4*ZlJehQivd79 zV4+?*LlE$kmkv{+zQNUs2X0k8z`eAi`9=|8fjYdlsm)=D*E~jmQDow@tafXhS9ryM zggm4mr=@Ch5Ivtl*IL$}@Ay1xp07W(ZGQgtzx8jH{Qa3MkfKu=Dv2|c{`Omd7JC5$ z0O#FZUzXR&=w!rqL7WeU@#A}GOGl3qu|HlY=$>>lmX#B`Vm!8pPCI2MXN*r%4KF?xgmbUo$aB6S25xkc$_y&r8=&_{i)EGyyCe{3z4X|K7&lrFJNY;ffDg{ z16(907X|W*MfA4t+nd0cK7LF7QxH7CGc|bceWAduBd_F{68>Qw-O?F{eNOw+H7TnC z#mi)3tR*q4bTl%(vssZO9dwKDjw4;5UGC0@F=|ibB3$bJL2J%My*&Yd69&iUdvxei zPah>6>iS@{8IcQxX^5j^XmW+Y=t3xuM0z0L#9rBt)xk8x1o8Yl{$+q3etRFQ8u9=W z=%5XWypsM*3^YKreaBSY#Ny;CMhz5#hRVGPfm5@kE}LOrq^_To5}sJT=UM-}x-RB_ zic?Nluo5es(@bW6>erBORcDi#bLCayBWTXa?u){03|=^Uu%7yfyFV<)yD7u&*j zkJINdVjc7yfiP+;c(iQJbez`4zCcN*h)<`6)`i}^D6h%j_WaIa!T$(4t&sDnNivrH zN(}X+f{}866Z2(kJR^&dI`nYVI_qRYXf^DcCTThls^|dre*?~^5efQn<|qX%2#h!B zys6h`Da+IOW^^Msx?}v`N*h+DCZQSo>IbSv;VulKZ3sgc#S$YP z`0=@w7fO`3=_>3vnDX-3uBhK^etzndb2HNZacXt1cGkqJ;ihh7Q%#k9q7f^!cn-9G zb#wK~@RnywpHKNMy1Y%O#8oO^y6;!ch$Rl~J=1>_8N|PO+f(V{A(d!blgT;jli>X`%$YLDKXC(6Wd?wVhO7!zI<6)Y}M*=Y?2s4$2Paiw~v^ccZ(0`;g$DyXMXsr z&`4=laX43TW8GelS&#fI`MTAg-t>(}{0+7&^;oqox4%CHrO|{k-U`jMLQ-?ei+i?_ zUp)h`50`Sk9>J0o9Buho^$S?>vxv1`|}g-ZJa;%&(2vbnJe&QZT&BKq5XQ9 zRUmT7kxFM}Ls5OuBl_inWyGUP>HZ_tV~r55=wM2z;b^6H-~m3DIX8d*x`?mj8_qo} zn?D&3Kx`P{?;)_v+ELQe(QQUw-t^%URsVTI@QdY7G?)4dR$_+_;z&mS2XjnUzpTQQ zB}T)HOC3GH7&;?szP!W9?dH2&zI@B}@b_<7t$Uw;WdGy8NP{cp(E$dZAIkfAzLBBx zf9W_^9B!1?lp^oPSB$g215v-FKc2(Zh0Eco9%%ioz!g%)BYm@5BEztl>Dp%-Rth2~ zDABFgoDyRF*&Tm>0y1&B+*i-YStvF3Xcd*W^k;XP_x`H4R$3YXoc`vA`_LWENZ8bN z#C=NatQVK4{K1x$nfbrid-HHC*S2l^);y0iQLQATIUz|js3`M1rNK}L5i*2Uvt~mg zQ+5!CZvQB~wX?gfjg0m)_ERmy5)f$#~R%9qH+~K>@Q(&nP{h&PrlpA@=5y zVnAQALY&e9mZyWEP3ldW2PCHsaRYvr{(a~suXkfmqha$1M>r|s85DpsNJ6AF#1;JU z&&v$;#fZUiJg?)v=ezUD7QA>tTEQ2SNB#T^izTRw(+V-q9Q_N0)#+B z3?w$7Q9k4L+WVJ-TUNyV>6`R`L-IUgAMq)BCCJc0F z-mR^yly{l=B&Lfex(IU1!r7euDzz?em?C| z;<&!+bnsT6_?h^KplTO+GS1%i$?7LrU(F1@mA&iiqE-YukXyw3=|)Lbi9%E`@D%6; zQ191ouk zUX!F}W4K}$nqMxHwpCwKhfa*4ES4sQguD=Fl}p@VSm@B(Al1p~bGE%1s77Z@BzmXXjrw_XhO@h0`TsoM_h zpz#JYtAQ=dhj5POhvgBImU`d8dff^=Mqv;bb1sW5p+_vT~90qTh>7so`G6B*mW=rO`u?_%eAkiuMRPgUc|9FLHY5DMPdaT?@p=TSQy$r_V>Ea@C+glk2AHHVrb7(+?U zjq7J;0ZV)yj+ z_PN;l#0cQ8x#~y$Z|}2Tet+Nw4c!XyyK}CqrMfZ|i4}8El3@lzL$iiFqgR>wt+K@! z;4lq)paDwWl8l2AdI_Hj>UnQMJ$zVIUTWH+c0gy$Jjhpc{i>>XwBN+BJk$i;)<8Je zh6eT^0L-Nz?bxwn>~TwZ_Nku0paoFv3%R+j|D`_QkHl#-Gu^%W>60~IqMhIGnw<^r zW{q~mI_eq%9hV*Z0L6HUZd7j!Y7z?St`#7J)k|{v&jn?%c5m`_81%Wii4v>6u6z@K ze_a>|;s>hQn?2^{pVgS=>4>_h+qN5m?leM-L|K+2)F7!I?7;;Z;ZM<;eF0U_c{G}n z=yBnC_ha7Q@4wcAjcQ%2RkFm~q4P-X3e>X4*Ee}1xq5_W>`wH)&U1Z)(0K#1_ey5? z@|RlJ3wIVT(2UHXydAteQFIx|>FVm@I5~nkM-z$Q-*cU++5!o-PwQ=uvO!1E^|&|@ z(gDZ=)*RE&zltpGwQvfg9@~YU?aQRijFN;xgvJ&RvYj+{&IXO6gf)iccR)Ow+QGlz z+U!;V6g0E_7}mzz(0gPsaOp2ZvddgQUeZe^;v)X9zP_Hc%P8W6M%l-UsIT_4C;~cN zj*Qw)XH5SB-Hpf2!KyV!&|I6ajJh|-EPApR~8g_3>`hi5Z1j(5(-2G3$^aN+B>wc|6|fU zVQ}227T=7BScJZm4##{2jLM}Ahq;J_;}{T>+ih5i6foBifY#|&f7L*C8<%H8xoLcA zdjzM<1=Qr?-mL5Y@nCb@<~bx+$xZq#Y$;u8#vr7hfT@ML_ZC8)3j)ZkJ_PtvS1#$C zQ9+Kn{z_x}EvB2@3$-t9>NGxq;*hS-H>Cp5KfH)^ncL8Z-Zr)Y2Lg8-tLOOk##glQ}%)ll)c2pvsOzm-EtGCPnFFMD0L=J+f`#a|Rdvjh9@gQd24 zeJNu@vqaU5f>sQNrfElP97x4f|oC~ zzA(b`U|yUzD%8p-*MfVH2bZk*g~`+Wdj^bC7L0JgvuEd_!kGMie*fx8%cx_~*~2%D zvI#$kx!M1hEG~6l0cp}6(7v;MEjE%mGo=W=iVM5e3kS*W+O^B&cH#jFp~;qaX?9 zu9zMPjDXFVl;`Ar_2qA;>L37GA4$fwLKASpG3RNa6XVyE_Wha>56mc6AW3V1p7j<| zbhQRZMw5!P6Zh}Y(bd&VTZ1Ty8gmttIpIcC3tp(*H(*@xh(hy z6h2vHPP2fw0B2|<83l`_C=xD5Ftt2{abNRx3pzazf_~=C)Q?A(822k61v-6I@4#@PY&wb0QS(w5EDdc z`Fxp3Yf1wr_us0UhdRGoDnvw8Ib{fGYY%L$PIDz`IdVe38%nydRrVkJ!S`}JoCp1U zkyBHbR3%*NzYjM#ST=o5nX zM0UJ~lx^(JNA6=?bQpX5WBwIbUC3m3@X^3j-9X(`X9wyt#`%Un50eb(e-sv%vM-A= zL28*KDQ@EE94urHcCsPG4K!9L+Su420!gsj#t4tRZY}5754a!lkUiCV%*?WZ5%VKSTsrX zY2UXta_smJfRcg;soNn~&kkfhM6fl-eh(}Qp=oITb1GH+ce&mAZj4sc)BAG7V~m_f zMSy%;M_)%+l9%KmR~2%&MgZ#xNfYhtrrIP_jrS(6{rAf(={hpc20iaIX~ZlK%T>aPMBh2||8a1tx{#ZT1V|EI1X@WltnBVhfG_%9k9U2F z)u!{Jt2{bJSTbyVHM3x@| z%Jd3GiWLS?0@uy3nW!#RwN@a}Z;OjMxQLo$DP^|PVI*~Mmw_xKt?#KN6kwt5!H6qY z<^Zxem|n`x1x!t|sJ;eWjBAqrVjT}8-aVW=)kpFQ-(e3vdy~TMp1z)Ui;?WPC93^$t$~ZZvx8;v5uN3qVjUDvcz`YaOdFRA5kP7&&<4It zc;)EgQYtCKJ~t;akX1ngIB*beL@7iA+fvh@92^=Pht~Ajy-RWT@*WgeQT4%tw$=@E z#_`XB0sDGwcF%4EOK5IM_*zCaWW<~GRJ#YoF#xj;_`!6vr+OdGI^JvQ0F=v#!bMnf z6L?aTrdr;afylxhCytn(q8J+9hqfSC`!zjp6-_!nzMi+35u=pp!T@Oy>IRZh&#@*_ zXCyum8>xUA0D6Z!h#u3|x};C#;jiAOS`O7)8*l-=nFm~uREJfqcEU5drLhx7O)Ci2q!6yaz{v~pgm%|IXP2vpH z{=~)w8YHS^L4Oi!OvSFRg_gWIsUQ#s0upFX357-w+kloW3zRGh%gX$gU`7&mmstP3 zxw&o&WI?0sVB>m{i7!sHdoD9|@3RzSuDLiDo_sXW2DqsYpDZ48+^WXlyK!-KTMWLc zkVG8`l;CEbN=Pt_qbLXc;^W7UT|2Abq~^&IC$Q*Kn;%<52wF;J0gS^`HH+i3#CF(C zLTSN+1DWu0AT|+o+IZB0_qjWMZ~yIn%)bu!qHjzu=rxpU$;Ke*ifXI4T|!Qq8jN6y z^qSg9=g}9?l18K+1lQ1?*hc4?-BS(R;lSMRehcRIb&i|MaPr+@eU;cFwt>2BaYP0j z%kh~|TfC(3-unOoA|fK#+rZL_m4aA_)DF1!PYG45>+S0do+NcSrn6;~(MSDFPHp;| zraPBBuW~L?9#(C8R}B9j-`ZF2T(Z|at1oGns%mewe@mjga+j;UxoKA4d{QD*U1%9P&w((b?p9zZ-lY+64AIzgf~2IV z7DpO@G4&c6K=i6QQaijQ4}Y<4h%j0bJcO#wdx8$yPx1Lu>UA?G?LHrFRynn4w`FRR z;Ng~4WtUr4WxYx|`$glOeL%~7d6m+>gYEk9ds_dvCSF(Gr%9CM6Z_}r=&AS08$|Aw z3q(9Y4AADA@61o6CZvSaut>?f<;oIZ@XoECL0bXaP;1tti>b;sHf`@*muyS^u;i_X zfo>aP6K+pO6i0nFJMsGu(7bvhftMVfpBVf2l zpW2BL!nnB#A+i9p7kE{$_4zrM{V66A2;f1qqDnfq>&s!(z)Qkme3=MXIzmkFif9}n zUukeP!`&UYhFd~7uYe#K89>6?1|L)#0n?sIHcdZ+nz?K%YEKkKyQVi0hk&xWxIBif zwp4`oBe0p=D=c)e(--PJB_V5c-X*`00OQdIF>!dW0T$b%Z{*#QX#ra1+fL; z|A)t~xx`0tIQ2I7eRJ)z^f1KfCAGY&PnG>=_Rjp!oVi|79}kT;guDxzXpZ@DDRrfE zNM${My*JOSraBv#7;nawEJ1`pl^U~vBsd9;z6zw*#HJ7k*sns?4PC+535)5%ST6AY zQHsIccb>Im+DaLMmOxgxiJNt*{WCdJ~IFdaZ#8$?c9`i6s9Nz)G zfsHj%w*_Kg()wM46~NjeV(3guOuKPooBpJvN?02i!v4V==0Il?JNj`rV_w672s8`dM;C$@A4VvlUXDE>`LAbLw_ z3F+yw%a3aP-wqz)Jt|nU>)G)&UgQdl^85daB^2@t>V6xcD$%FV%f1ZzaIq7kTBf9o zJ&yKZ4ATlT$fXR4{U4Ax%3``@wXN8JD5sFvF%=t$ds$CIkkLWud1`T@AaTh{+xqXq zZ4?3Q5tauRkm5HXWt91mPa<{*f#xK+u?FCKJyFO}o68Dh+?E%)4YPOHFqHRE9S1W1 znP9#9)4QjB9dh=-!`P4<$-NNr3bB(dh#ay5`?&(FyPhzlX77NBvdhM*L0{ESa}A^! zGX#B7r5M4=8l>@xRKY{%`}Oy?`kzBuVh@0WW79x0>&@@$l46qI6 zphq*+zl?n5+5%6M2gMN&T65CXabn=dN`K1@e?}!=N(<=&q(h3l9^tG9`*=VNEo&wN zTDu!2H|!a$BTZx=rW@YkwwaP?gfEgr3=v@nI?Y_r??K$YXdrC|d-*;%>o!Ca$1N#% zAWx=xXi#T{0Cktt!OdE^Ulnwi-~Y%;7h$h3>>6PsvYtJtJYa11YaR#!cV!5yxd6B2 zCCLcQL*4LkHW{{#hGWwG!029-?DyC#cA8~RK}Ik~xmS&)Aaat+}w8dcaj zFs)-t`X857e8Y={W~r#EU`7ncGBf?9zK={z5@k6ECfXj(mjdMsFai|)8J0jzfuel2 z#t|}l(mO&%4@sOH%IE=Go=F~vkFVxf1+QMVk-3^Lh?-*gq~_77!WU}3!?hT$tvPt{ z;6`LPi>cO51l3p>xW2i<2x@=-2B~`i_tWcX1HM=Y-XVb(|0eb%iAM@uNOj|% zFijRO()Z&~EdpL1(d&RqQdSHOhCwl3|Jw+zVJG>J3H1II(FnbRjmCyx7>I#BV z+c}eiH4$8Dvi06b=Z%*C(W$9$Eh%qHfog!3XSa=Uyu5CxaD1kmH_EwgLDQK)%@hqz z8K*qP(#zp2v011-sh@99qWQD&k0w3QpxM+`?u?FflHYYA-;PNu06VhPVIulw$CXD96M8D=aR) z_f-b~AnY2EQRDLRkSSw3x)$CXP~b`i?v4KbV#4C6r>3Zcf+|=lJ|o8X<@B(>efUs!+0}Zvx|^RODYEn(DJ=(SPBC?iB3K~6{uc-a z8wLc92PA=pKt=!HUXTshaW{&y#1>)qTi_g1AVqWnq=H&CJNq9xIE65O(rd$R?mN~* zGR#D;C;kA5VC(4Uu;qx+G%+un@dQ}_Hor!Y3O<{9!c2Bq^M2jdOl!uny$1K_+JejF zQ!q!ua%gwSMl4?9a8J;^8`+lS6WjhfWCt7PFf)yGTEBamVy9F=cRMXcW~U~D*G=vf z#Q<3kYH6h=CwLIgkdUmcjQhrENbDqeM-LikmJPjbe}E|$lNm=U)bCi#@NnvE!jfA$ zzu{)`cwWf^9AE6tyJ*oO;`uTVRhFAO%xn+x7%{lGJRnI~fea(BriMGjo?lKyXgs*a zZ{-tWjg+D^OY*bE=t~%g*@a@&!f13H(x>$_`-#M5iT53g=DM5r?{_U~;l`nrSj2c( zDn!At@X1DKWFrRkqgriB2NR0eUPu5re9J)YLnO`{IG$VLNi_IAI zdZisVhCZXw6p$gLvB=#Z7GzQML&KUe{NgEfXe04oLRz9Uc&&It|Mh}*;*RVQi_k=R zvYAv3CBm6K|I7|##9roxwp^ewy7u)Fb&?u{se%k^vA~JZ<#p#m(Oy0eXnA}Z&! zxO61Nq72R^b+UU;@dZBE%st1A7@t)KGC~y*s!nFk^9k>GKhH-GZa)U5=_(2fBye+cX~X>8Y1z-ph`7El5G zRZ`U_{y+%217$s^@I$C4n`2Gd!^9w4F2Fo9;VAie5Nb-Xoy=5yFM5%*EipaAlaDBD z1a%XtDGoR;+n<^81*_n@>_L!_nY6}1CjruIR8fGcLwd^_l+<}tfQ38F`n^Q=L$=J2 znj{AV##{yek^j6=b^7d8z$y4LNu(Ocze|LfWl7`nYt_+^!1?))be#7TX^;;vpx!uw z{6T!rHfCY_<$h2W$Acjy8v`}4)YlBP#s`V`D`Ks1?`Nc?+vR_)lOqoo08I~+0gI1a zMApNA@u~xdf8GH|-&uQvP{YPw?WBq&S)0Ro)bBFXv~ z?V$eQ_+-o8?k+0d0&kBFuenrpSdxhR$f(IEBYc`CdvT#Q37%U#>!CU?(zul0 zzLA1-)(|y^Fjp#2QdJzHo>l=Jh$Jpvyhsw8GzF^=1mQ2282d+U!yb;$a1A7jQ6zN^ zmqdI)>ektQ40o=khfh@}p(UmOMYaJU7Z)YWs8}u;$Y;QN@j*2m;NVSo3lbOCi9+9? zAflv9+}L>pi6sBe=BlEj+~+RCF$%7y{Fco*BTaRQ>aINQZ9onRNzTp~p%o1fpfJBd zIH+qY?9(s&o$nk1Pd<2^Mx7D?sLRqUctLj_$Hptvqf`j24Szx%;0t#N^=}m=4?51R zc$xELX(n1+WHqXgKzfgMOy{o+y}p|ucWAm&}!K>^091k$Qd^B3jj_ZzRCB4KebC4L z-}RXLfrusu=bTo2#^`fFZ34eNgiZbBf>zyxcW0Cte|0DpBEI~4t2{v0^Axa!76*9^LI3{dFW~!dm z+Mmrz^wYm1GXMEiFJJQ+(TJP}3H;-b^y-vUokhU~E8jh{vcE*YQq!FO9q{0DXhDVG zn3?4!WzLqD44gmstK7(7lv@M%N`V7bSur*?xFchOOYE6{@|y!@`t#slTA!%cEK&qS z0wX$UIF`@PlpAlW!~vP~-Fx@$4IqIMZEPy&4Je|Ekem;U`@k1Qcp~BsDoYYokCde- zaiEEH;Qy5t_P-`KcVOuUv0*{q^9PDSgR-*&8DW>261f=~jza`bB*-zp>^qRc0Dx2F zniBQjb{6INQx@x8LStdRkz#+ez!IX;0qXe|iPHjak_&|4mn#$GNs5ncXiMNj^~9Ks z=@ZP3AucyTP>bqV)Bh;j3zeu^QuVE>!jI$IC`y~is=MK4M+-g@W>$|0%`+QV6( zvUM39f}sPt&4#k^Ihqwlc`I;Cg8@+xQ8YV%jL6H&l2>BZz2Wb; z#{K+*iwPVPOZ{{P<=eDhuIvqDkm^rVXCw7mHrPb`cuM$ywpltxJ3uKf;qJa2j}?*anc&L+WeQL#9MnDh;eMMsSdec=iG)4z^Wd z6zgy^9@vZaIMA#j#Fw;0?1CpM#mRM&GRn*b$nBF+>2pLSmsp2rMARUY&>4X6NI>#yV!l5of{EpniN2u8Fi`4vC5bTk z#HU7E64G~?2}QOHqtvg?yvY10p>$~0mi0h1y*tGO^DDmcWfDJ5S&Z?qBK+c4Nb|@e zpa7jB1+?GY0SzRj)eRxLt;(E4*#9<`5q-&(5D-lh|JeN?1X+Pz*nk;onJ|~0eAFCB zg>ZtYK{k^|i5{Ii=ZsLs5podef8u9>SbgM}WXlK#qoyse3+>y@i1(`5mjw8E?(DA3 zH1}<}F(dGv2UilnN1StNrK>;-2TiviDv=4~BxI>0EE%0B`6MVtHQXy#uGGf$Usu{G zOby>3J9aER8V%vVLQ}xCckf=}L?BTVW5}(ck!Z0y_lz0Ti{`^5q=lY1M&UIeE*_w; z+|IqI$!8-W6Rlx{9KohU!~~K+-5K}{Ocu3BBut#jcn9jL$X(O)5oK>(zrHe$5$g4F z*lJH$0+a+(OiU5i3@{;guZ6^{Ie-Ah7xhA&5`ya}U81rN@mi@6MipcnDWV8AFXQT8 zgU}PGgi%|N6#8Y06GdHnyJ>bwQ%XEKkCATyE9N$1&{dSy0&0{kb}X<_=4^6qZSylB zkRK2y`?aG6nixGG5mrGWj9MD8WZUxzeI`Hy`#&vQw*MxiA9;Tr(kMcd5Wq?c2Db3P z%8)h-y9w^+SGY8>rRDLO9Nyi!N$LWGAI;r(T966tDRFp@4yK_m)FVRbL>dOV!ft`+ z;HO}c+SZ8YS^#G`NrSPejEFGrM>r*EaFDISa;tJa`ffpp#6b-}M5i8D)1c#nU7i~S zfQ~B7lqTay&~8b4TS`zWUIl8|rVUKPVdWdpDfMe0ka^H2S^W;}fv=!HQ`GVVvUCvP_Wnkew*XE>;W#Q`Xl6nK1R=(N zLBoHy9oRE)4}@fuIDG+kfGh-NgS_~?TL?^16dR4ej{)mNx8XiYtaZTCsjC45yz+f> ze!f6z)TW%&nnnlEa9c926u%Hw%jUvCg|U|nyrD@m50wfZ>XS%8uqIOT2-xV9&ER;_OKt$3uFta6wgCBJ1edquX_*{i777q~7o(6i6 zAv^~4q!ys29n-+rASec3A2g7$@)+od^R+A(PO+y-gLe z^uLljSzOP5LFuSdCLa_x0^8BU(1w;X6G)uMdZ6<(1ZZ|C_`kGGz$N!e=Imck!7cL! zHBtv8ySougwa8Qr;#HuVhibu)z@lMebx_#Io`2I{rI=Zv-f(01GoptRT_Sv3AU8L6 zEatY~fOw&-2g=;_1ZvP*p>88`%EXdK>sneyQUCR&rz6vd!h+FQGFcC34zaIAYPRT9 zkF@;&WFns!uyl`m_U@%Sih%-XJ!WJr+$GxoLrNaUV9h8RBIO)T8DeAVp+Z35SM>xb z0a@tmQ`2HCdMI*1WcCNsh!ACM@B>F?_gho97_TYPis){`QOG6s6iMYGxYcTrq!1Tu zD4&RXWkN(M_<)X7J1r)rCIhq#6;po{nX&JQ;Kc20fS8c|zu=E>-HH>V85g@ff03KT z-o5f3&X5;4Sl&UbQ?nF?1;4XLaFLq}suXx6!jIz*wou&`=aWWwau10A)nQ~odD{x& zocq-SN#_*DO5y4_x|$StzS)cXK~ zxf1Mxm0|o&vc9~LOD9cF0$;FqeMhlr9H-2uaZ4C`{&x5a5~J|$`qcm1(gAp8820_z zvl*Gji}}n9T1o8JeuV#Wo#cPM$Xwc2<&Kg(DASGL^8zG(aE*UDbs zs-IL}mR~pa(1cZ2HkT@GSS7?eLTc63(ESs*IHTtT9)3EJQ)v(H-+%L-2;Dq!t>6C9 zk4~t)owP1$&R-KeCaBmobR9M+IWlXrooG@}iEY4^mjR_IK0Sdb*nJ6{KJoiMnW8H= zbT<6ypO~@oZc~1IYQVoPn6IB4Ec2(Y@RdIsvU|X1fBujEe3>tQ*(C))I5OUhwlX{qpQjSK6@p@3hjv=Uw3%ogn6Q3aTT@VH%4ti1aa71>!EuZojQtHey zo;<;v))fddGEr^&)Yf(llATbO^8@dE; zx<%d`m--ujunf;b?-81Cr1XewF&?q{6$Ei5`qkpvUmc+)`qWprVWunp&(#|6Z_6tS zq;D!G+3gjzsJQeY8q*IO?-d6~xvqis?ci5vNVox71FN&E>-lZ<1w7-11I2XJiZveF zR1(#ITiYD(LazogH?{`fKx;xa!hbku z(SN)%8Zg9Q78W(qAr-R|v=&aGSqb~kN%U3SRu9YJi8=9ye>UH%wfw?L{s*y%)k+?g zTBy?NW7*q>(HQr56rbFxEfAtq+;zIM^FVxR5Wlq3l~=E}&k!}={bgx}yo;1;#``%Z zM$QsaD!bdU=1Y9~-Hs`3N7P$|+k3oiQ)RUUK7@o%78YbYlCSnn|2BE!dLF?hXK%(D z;7-QiPQ;7?F8%Yqnm^;<--i!Zes%F<1&nO1?dmA#K6&z_nBL-Mn>{6&=8#J?X@6Iw z{pD+o_NZ_k<1Z63hJ;;C*;VFr?ybuk|H&=w)o;a8(+^4DBA$P^h;Xcec*EtK9C19E z&@T)9^Zk^j$)EVPVdKWccA;l}Izb~xON|6~hz<2TU;x^G?g zu`Q`paXJ^5ZF-%5K9`W%iSDkpq+PrJ_@!+!^rc9>`=Q#g{45-hqz}uF?f3{-WUx}2 z%fa|Fe?C%|=}1u;&H)T`FbITc^<8Ml+lSKL{%rR@oSYMzAMYOYS$*fOUE(NbH@S{G zKG-cIBV+$L0Y1L#x>10u)xxzVrY}8!0*ZE;izI8@@x%DRWd}ZPXCWcqf$7&A9WH`@ zIyn=UyvCtiEsygB!TAgk8kFUY+FyvS1sDvGY2UtmYXeJ@1T$@FGDbr2Wx91;*3tCW zf6bpi(hV3mS_?0Q_f7co`p98@ltBR2zPo!O7$jVn16BiP*!k_7D*E*?YhXR<#v{gz zS>bf)k3Ud)kzd-N4)bzT!rF-+ibj{m)Tt>u_m6&Uq5%29KmL++(*FZN#s8()<$o^o z$DRJ41HS*pMO%1m$28;d>z1RFM*<@~{>jfjht}%Ll05r7Pqb~ynf3RjV3$J$At@cv zDdP&ObaN(8vG^danzgF>`VXJ+)0Dvi=H`T}=5_H4+l=$FO_lqDU52aK{>5@~%^DED zAHKGlFkympoM}-^ch3rrvQymv6;|?;ZT^!@Iq|Kls|&qtXBN87?px?OeBWgraqIJ5 zUPp>d=OJ)19>3{N@qn|mipnIrq{_W*nzlp#SAjLfRe!wX)8>NzQZ)YG_;UXLF#}6# ztXAr|ijGOoxNu^LQp(Bck&$tCZ3R8J)NI)1$ol3B#S=-l>anC5KD!6qJ&|zz`t|c3 z9_!Yv`@3nG$OaE}HOrl%CMn|MhwLf1Xed(TpO6h8GYfhTtUFo@%Tnbos^C{AO`Z%7 zz;k^3?8i&Tba(GRuqEcAsltX0d`+Nm9z#v@BKQZs(9hi&U!FV5$YU3-fi(uL&PK$u733l5B8gE-v#GF-T|eO{gPksp=U|< zmbW#dA{{-q-o)RlO3nEY;x}0_*kxUXyodm=A8S#~8{WBdyKrHxB)f>FWl~a72$|7z zy8{w0oJ+Pj-d zajf7T1pNr&j|0tw3fwqzQH(5o&k9z#A%{Ha=(A@^Nb;&Sh#ecxvHtDIe^L?8stX+?JXX6sDi8L@}*qy zk!I-kbw;ZT@)_RBHbAm-7cM-Fp4-9*T`}v1yuAgRAL)kHXH+6Td5Q_>>+}4@GcU{? z-jE+e2`JXA4dsewF-BWnWgVI&U9NL~!ELd9@lba5LQQbej2Uv+JfP!o3?DzM76T`Y zQT<_In9OPP-t2BoF&tIoe`)?+`GW{~!Xb8w4&(CnZg54`BQ&6Jzpul!&pvk*@AMmZ z<8lfL*!7}3l8#d3SE@3yPk{#Z8`@jWfv+DyI8d{8&_gSr}pX|WjP1Vz;y zt-I$Xsbb6co49S5*$n%7dl08zMg-)$+B!25 z*F1*LS)sR^ehC$bCulHwd3VobJfZ}^+?}Wt+{NEiR!;Gc6Y@~Ts@=@JEGE3KW&;aq zPl_0a$J#6>w-Z}JFLD1#j1c;WG#13p;WM9JOv1j86<6fJurD41=TAey3gqMCJA#Wx z<6UEEGcZDc!aX$f)xgjr4`0oHPA5hfhrSR!w;2Ee_Phw42qDovy>p~Gb$4(1MYOk{ z#va0vL3W9^JHpMh==S{&{GofJ4C#Q&_Z&&MY^snG^5ekm*#m2J4qZ@^s8tQd)_H>_ zlB-zD>meaEEiH-%4y?pE*acAtT3eJRcdxtsW80OQqJZ=uF8-?{wx0Gq^XVvHnxOSH zTqn*wIQXxx9W9F3X!6rz4J~hrFIz7y&4L*EO3WYQNBWHk!2viQt>{yTcI|V)FU%gt zvr-x>h2dTtEcAWP61{u|?GPRh9!Psi9WoTa;`-ppu&(1DfW;z@#l2JBjI5fD*}LM1 zEvPNMj4>KbSv6=VU;|11SS}oqOjCsKTm4pybVFingI`w(*II_VOGmdlQhq7=BDjYQ zFr73*$xBfAVeRuRcGt0C%YcCZd{ouDvHQC|L0e*SnEB{^>)87Q=BC+?q*!sZSP z8yPZe82u{2NqEZ&T3VMfgVx1N?zhpGek}fm$Pm?}4bDn%wOF#@uh94!0=nJHX1ng5 zDF4Yj;>+g)IXSnwbp#6>ByJ2}i7eMVWq9PB{OU)b>At*gBjCM2(@uVa$e6=e5f;WU zWP)yrpBRd43@_y{%1VCXhMDzb{*Wvn(Y~<6U=5OZZWe?^7V&SrB#m5XrEBkMkPH@} zGiDd6(#}XPz{9@`-X!7#!`8-mNwBj?;oDODU_MoDsmue1bevmI(CjIv9u*0%0N62U zo*X`!@%RjPE>GkE4%mTQtWNq;y(cQe#?IJ)d;k_Q9RU)W@}9%;Z^K~WS+3ptV3cxU zNb+EMa%UzO>fRRLN41*^9v%;&0fat3~vL75ixm_Lk!=no@t-;c~`@TE)B;7#VM-{wRQ^91QcU1f>BimNiC;q%t7 zTQ_LmzI~D9n;&?~hVjO)hgX!7mmeDWLJ5`~TMJVDBiw3h4Hr%s&B4JDd06^}oOcaw zFBs;FMGFO3%5S+{W+2%n+7VuYYvEYL4}AO!w>y`GF#tP3p~iT^voBt#5uyf3yvJaT zj(C8+)RCh`@rsL==Dgk_3KwKwif6^Kz|7HD-8zs>@aKC5=O@}VYNNJFpFNyA*A=UGFGQh$s=pm_vUIW@z(0^$yEcLgc zFy4>Y_l5m5HX5ooD(IWZ3x;+7ZmcR}VO~8A)Ivr25Kdko4hD9lytDIatLCCd z0h%m2BSS}VKCpw)MRXNnC3Zx=?;9_S+Z9L^HEp_;N|y}-MwWNfE7cl z@`1+?GyvLGDYZNE9#(oB5E9hF3lnY4OiLo09TzS#Nuw2HVY{u@)8nzK%NsN0)KPT( zEH!*O0pb;njtaGobcDi+vOwc#ER7Wa6$NSj-|*^e&?G)eA=@I}6Y@K9K8w$!zus)W z&f{qW1vF#QgVk=S965HZ6%pA|>)OreL(&J2g-!yUL#QT<2est3nM3+gfRaa!9C?=J z>WY`ivC^USy6+v?YV=le^!24cP%VakA)4lOvNQkEH#mpBSX z{;$8>;A4{BDb?EH0aR%e3k$*exXupg4g~j^=>B9izPL4c?b@}-*N)&UenMx1$NBTy z^W5g?s;0^=p}lYl zEZRQ^(&P|_wSDg_h~!r-*fvcUQsndOY7w#pCr&9Vay_9%Lfk{bmH8(2AEgYE6m>tK>^@p z^A~PWwVEVKonWrW%Mm~XJY62ni-k29KTX1J;ipfZ5Cq&eeOAi3Xj}57&`?3LK)HS* z^4w{LQpiU*Ma+u%R<67RR)kG!t!%i)0(=GXbwd)YmpY;68LBMFFW-k3Di5+ zJ9|;ht^$P_DWyYH8fl%xh)u;T9hVdoEh#1z}qt|O$z02mqR~rn67N}7D_~1N?r3zdpGSE^o}a4zsBR~ogzf+Q4H>};keCmGQ2rqV zdy}}h9w9n9aq=W^n|#~j3r)tlfR~Lu-HQE0K~CYC!-h*fM2Z^)7#?xdg5SI2QTig? zJ?YkQt_w|{(%N}>YqF8mL26^ps#Si-JEM(rXHX3T>>p^xthA~NS8h-^^0e}4j-yRg z&4#$Qx?|EG?2Mkk&Ar9cR0tuqO+foBPR-#MxlXEs|EAI~-3g;bemjq|01gq51(m%;dwHLbKrtAA&~YtI{NrhqDl zf4Ne^^2`UOaf!X#u5X@*9&}}VDi;f4Gm8~e$`5K7N0X` z4%&_;g%$aI7`2IakFUN>)~fq{HtP;O+BpYvnT{Mi8tu?#OebaIS)R9v^6g+{K}=~j z1#Q6(S zoSS_Un}SXvJQ0LmgPtK$)cwHYzslAfn#nj$hZe+-DfG?qP;Vb*g_BQ55n@tLA#asf zGNq+HJPa}CCm;9 zCY0dHvlbZzSS}B%_p-5GuqQs2P7pSl03?E`Mhb8q;u?;dhVS*VwU*RYx5SD(?>HFy zz6-e=(Hui{;}^r>Zbz_7p)?Y=_aRZf7i045eUMYckQ2BUibN)6})SBn}>-nUVIjL z(0OnWCrz3psDAr}?f8n7JmX+bfw=611SEXdF)Vx_O?(tF8)lWA8A^)+tr+yqoI@AD zAeixHo=#TmyRom3_!$95Ft13sfFphmx<(sJ8oF2}J*?Bymi>+VM&-8Jd>|eu9}L;- zBY|CxPPUVf=~u#^gTglz9L3sF5{tFxey6 zBlW~nyIZ%w13PEymhwp0oyN7%OU8Tk>eUgWMqR~=z$nu;P9e1s30=M!Kc1_hR^cAb zV5AWOR46MP0^zm#`Pv!m<5dMR*^NEIAB*$Uko4mq35Oo%vR56y04UhVXS~}MHxElgvI48m z!nNM7;$8u85s@MBNZVk&l|z-T?4QhqZM+T&HE>rukV*n}ZMZk%3UYqhm}ol`0KHiZ zd;C5KB?o|^bdhL=*<*oHc=mcPKff%Tb2QkKdfbp;Y(fkbbO#=!FRYN+>)#&h(nG2< z+JgoSx&%20(aX(#vYOvIS_E(&fXN}heCN1&{``}+O~ui8g~gHj*?60`V7DL#&O07_ zPkAbxJLN>eE45@b+I@i$zD{9{_hC_Fans8}LT<3PIyY67+av8m4{Y5Jk6->+TEuukj&%P~aaz0loax=VbFEn_jKyvaG z=<79@q`P18!~6MgtrqbHv5O>un_~kA5Q+r^Xm~Ih`^QXM`oK0W{&Ej1JiJZcxCjSM ztWsWzL(|b62|3bwaqC*El;UOuD`i-Y?+y?y2OI9mdphKzKMq-~9UCN@hTsgu@TNb1kH#nCxTbNuHF?&ptHusve9D!ZBpHvkY65cj5uf-amC=SvvH!y{j z<1O^vr!2|>hE@s?3b@f+I0fulD1=+0=YMRs)2na5-cad2jFY%QKq@Wgfu4#wV>LN<%Ya|<#l{U}fDV6c$r5%Auv0``}J zPGshIwkbsl8|rAOh!5PQSmoP&HA%OI!&(Smt1nO~?iv^SZ6vO@Ea~_Eb<%J)l^6z7 zDujv}QVweAh68!tu7}_Z$O*cgJOMEcQo6QrEK=L1Ro~v4#wX2DOgcP$>eMF)#5!SG zh`n=chZ6W-WGnGhK37V(@{Ki8DxVs-_B=wOl#Q39*COWldH2JI4_PAXs&;}7O?3fm z{Fv?k3__Fl>s7lkrDFyJ1V5N=9R(>>6cq+P06z4TbbKQ7;QTs~3PB5D8E}v{Knd%K zg7w-7C&JTL#9pM%-!k)k^ZRBzGJov5W=Cw?U7#G`2@2yRlUEV?nhvBi7jri_4nTw9 z0HTh9lw&plr;RUQ-F&reG_lK%AxQyNn-9tUX{+`N0`S;szZ@5H$%NwuvXNmLhjJ6L zPBI>_{~=+Aft1D~Xh(&iAyLF^!-gTi+mm1aIH~p`So@{1LEv!kx8M2csUB7Sd$N-J zViYpk=C{i@KR_6maNrX!nG@h985Z$xR(JeUT^$6Nz2K(eY>3s!0gHQyc`-QKH_dv& z@;wtOXKsY&#>-+MM}85m?Fn2^8F~?m4N`LeM1n7F--)T20Dy|mhWacGtMY$uC&5Ck z!vr}YhSFR>hWJWOz87H_#{2psEJ~bZ6FIlkr_utwoWiwP-r4O3`Qh?l9SQOWhH?PW z<#eQ)NX>5G7_eYThdwCsns#h0l0u|`H=xd%42D#^{|UHudAN4#y!gsyyDtiG*`C_% z!?IQxOhNb$nip;VD2F_Yc-2s)IfTRF5PxiIqYS`*&A}O+@jh0@N*iN0BNqSewA_)Y zU`6nd90@KN2nc7OW92pAE(#_n&!m_S=oOe;dw^K)KvxD80^p22(8@E4ODF^2 z&Pphs2DyBlk5-Kktl5#{#|N(xULx_y%kl66+c(Mbg$U2dwZeGcKnD`V#ZRAZ28FE? z4tqMl7z7D*NRj>$6m0a%=Pf;jdjW_@1wbGr&+qNkP3`%j3k{El*jbGg_l4mXBh9*i z6-Q(KEe<`aTVi?@meJdTYI{QvCfqdXySA`@fjpMJUDC|s z>4&hfV0~$FAJ3}&Cva!2Fd>7M?r&7WoKgjxQr!DksP-5kGC|0c6Q^&Nh4LKSE(MO? zW2Frsp0zBCt;ZREr22Iv4%aBfTL@|_KY6(f!XG|VWd<7;PE#R%i6~H2Ol8g(y(C%M z%4#V@Ig{VEB9ew4)B*wmq2OW-s5WU;E6k|BiOYUOE|-)q?K$8wE@Z>!zf`O;kU4WyREKrXRMZ&y)O zJ%dH(2CgKE8kZT6pz5M&W73yW29$0bI~_TF(uby*QZ5yjmK(Vf!Ib@{O(kNaLS^Bf zS28KTc4Yg-VpK}?cj1A9no{1|C7Jo6^2CjNei@d+7}un4A*feK%;zgT-uBJ?>{(HI zBiGQ%3-YSSX{cUJ!{HM_)-^VLDcy9*DlC(jx#;C(X2s!K9V}`2W9!GP7jH0Iy+a}l z!9$>ur2^hijAOfLiMs0NcY*)(q{{=HQ)JmIpV*2K&a`b`EIr&i`$#b_-A!gmMwHl(jN zlUD(*&;Tb4oUh)`7Kk^JWR)f zoLcOdL7I8p$%P#n>_m8+mrd$J&wH_1t6Cal+v~4meKCC95HJJAJGZD-0r;=6zWC;JQ$-_ znmTOQFc4&>iI{S-pr$lu#fs07Rl46j7~a7k#U{Lis{BIsFFl_86~US1rz3uYaYFt* z4WJUrBp=x^EizLL!meWxTBhR^quROLqGBag>rgrXMPm{8h_4`she$Z7*j{wqY?sbC zEaVM05s}-ApoH+wG|{>~XXLB0`BuFpOUDcvJQ#uIXf$0fXCd0(j!2lW2w0Y?qG^0) z2X>~2KYH@S6E#eDCssl8i4ZPienD#v-YGTbT%d6p)%bltjwrOB|7L;>pwY?GrftSg z>U$~`Dy-;%(I=`3YnrI}G*mTSym*mhx(@4=d)iMm&p}GDB2TC(*+-z55}=c9$K3&% zv*A!gy7-}|NSS?C*$N?PIovc{0(W0_j3k->SSukspmJ+P<;abBC7Q+ft=nYotzGi* z9Koo`kPP=-(;|0--$^bRwiX7}u6+lo$b#eASQfV+INbBJFd3k#TvdvPJ6c~*QZr8R z9i51OJjq{N{x>KC+G;3;4gl#5A1Dw8n2W~;MDjQ0%AlA6OlFW9hBobtEu}IuTvHuF z(|QEDZ%{Pb4#%~^{N;J1;wVG@Lm@E5jwenK?WG%I28Z@aCcRU@F-q`@K@DfDt-opOVXGiQoG2t=k-m^0^Gl9)}0Ni?&HGT#$^g~fe1$~ZJNXQ+mlvp%H z0QE)S^BU2{`>K@7ND@Gh$j3x;X&kBO@@8OyNi#0T)UBxlNu$m@4iIl;Pv)Yd3Emff|xHE@p^404d;X^Xk-@s9oR&sUC~G z8}G0cgM|>m2q)XTGWYi%?vC>!3;F_4O+c)q)E3ox{le|y)z?6*M~%@9#U+fx;6m!> zcfW7DwdU%GDhobX97J^!xVY*P=Vi59*w%y>f`U#P5I;s!tvQz0{pEIGTvBBofWb>E z_Dn*Sa2-N@xWdqc*z%cp9~#S(>LWw^+Y|!t1*jK0h$)7}Hz{Ks8rC+!xnP3YIv7%b zG@LN^?E$2_r52`f2E}4}#~M-Fa*=uwUueXL5r2t@6xp8o2bO!P>Jni?mC!^+CaUYHFF(WX;(?%a`B0Y+(LNUn!uNef=$Vn1&S+*@D8#) z*=Fj;Z~P36%dY^tDSZI|s1vCwL>)K~P5DdMpT&HPJ0JqRD~Za7nscpAadmZd+@WTe z9;hp@i1Q+0|6#~qDET5(1nNxta@hIT0eEY#%iI(}hQS}GAfJSg+MJNBz7LW1PLp(8 z0U2vPur(vgy};%KJz^ayZsedSQ9*409>=gI?PA3u#W1miFXmF|OHuj*8?6u&2Ow?) zu|Exxk^&0LD=7FhEx~)>6kEO%0|$s^d?XFP-`gnNu1$w7y}&r>%)PYw=m;|f#(5|=sRCpt6Z*a<^jEbj_r3`S}ZIz<4)V|K)r zo(9r29ra3_@1+QNUV}lAEx|KxE;dSg2SmguhJcxWj5>@lW+dgWMD23snMYk~;8d>A z_wk6_@Zuu)eroSmvuiMB6s2MC&d6PGBqiaN@#SYg)S8AL(n_#;J@d@kn2Q2Mm)m;q z4U7>m0$|zd*FcP$l5gO{**r$@v%`P2LqS{)a{XO|7}5^{W^j7)=KTA)^XI>fG+3`K zFnwP< zf!qFog^8sc(omA4vI*K1azARz0%W}gfD0fW9pIAbpHYb=CK$qsguFEnO5kp9Dj`lH zGVM=D8}1-9W?9CV4)Y`NMJ_vaqVa13}?+0#CP%uXQni!VZK1)22 za3XwPL!As@D_yv7flBGvnMoFNYy~ujOsT#GCbmjm*DS?S_-ERTFx&CY80$m$05*Rs zoLkj??YX(?dMsj1QKF6j1YO$=1aTs8LO%TA?BlE9ZDZNH@%~IrODAD84_WZDaYS8& zp_Bo9^dg@-Me(hGw06S+c9vl+@za_#JtxbabAR7#FglSa^Mn3})w!@hb1|6#hy^a2 zv0}G0V8DV!Ey=lO+U|`3MTm%(ST7avVe^2&ijgQwIZ3v=8D6tb^5=Cqv4ke7+ z9}>6!tqLHC2M7X*?}tXa8!#H+s2FCJ-m38}s4u`O;U4F%T)A?6)D@iKrxaBpf-9q_ zGDx6^qRK~jVVxKgx&?elIN5@|`V;5!^B=>@#`gEN;7tdI@*x1+&EVZ)b^^hhD6gP5 zj*P<|_8GUfaD@i&24og3jY8|NmM7S;37Ow@+6_IcBPfggr;r?CN84R`EgMk`XBRVA z(|A3aVfNpE=MtILhwNt~T8+kB&NY4!p<8kQNc3rN;nLxiB8{MbWcnl1M1{&q(&a;i z_%#?UGJziN~(^x6Lbynrz>Cq-PZz4upA*k#&Vlt0-;-_wX@J)M;4l=bPo_ad%cd$SKfa z_V57Wn=?QLtBRZ8m{6Z+KzgO1>1wdYY@YD-%3gSd7o7;#&Lkuxly6hiZaBC)uHGNZ z_#}tc^fH+M-%11=|9&^HjKU9}o5f_FGn|MjGgUU}wd8@1!OLJw-yotDMzZ}pde^2m zDCY{Foh@a-v--d@gsFja%g8Zdp{F5^-6$vLZr1bk>Cda^zo4wz+txknyz{1#p!6<;Qq=oh^HP^7$VxcE2e9do|Jc&uN_MeBhPY!U|lX z6UuKqKt31#&aS=m~u%_8;Y8^4oMP~W84(JV~R z_AYl>~nA=jrcP?Mouthh8 z`z|T(kK9@}r;WsZ5*+w@CxWx9Wtmpl+0B~3&Hu63gz8bVXLlC93GH@LP@Ic*jA_QX zNZ?r1LomBrDo+2Fp&Ld1PT!IJ{M8o=UMUkE-XGq($UEA8m z<bF0Mvz)*4g0hmBMY0Tl z`jCO!&1JhM->q8vGWF4Nm&6*-JP(k6P}&2mjEH`y)>PHhnhr-&Du_9afnqk&EP=FL z4365w5%H_Y5H7Eu+DZomxWgx++*9)fNO{VY^ZqFAqeMDJq@*k0eGujsr9h4q|nsSc;z#+WGIIw3K-8w}z|>;`RbCZ=$>M8!i*I}g&E4D^I6TEv}s((d6Z!}Y@M^*T~UFEdX6by0vo z*u1RSF*!is{u<+)(S>D#c+vQ;oYRJjzc<0={K_Ae5)gdo=-ujxRABlr)*L#1{GnOr zh7H=Wk#u*01PG}-4wOuUZ~RKazL!o}d9W_xmAO*O&g~w(ea!oIY@qw8l*9o$ZV*$Z zC$k7kQTc(6QqLKIBf~3OzuB66&~&lP}E$4->p2Vc7d;Q_!3m zEm+WzcSKK$zj(H5|6AM~@yt z2FR!h1)Pda+W84pRw#tfC5gQ)H#h|mw}l(vYvL+gfYM7rKHWwJo5)q<-tV8AV;)Bu zbZygreq%6`)Mx!t^UCNpVG&$I%Yz4*fmn@4I53175Xr%@#wU~rfDgWWsKZV}m+()~X{jBJT*BuxoX|R}Y11+(N z)>KMRR3W8tz30yFI2+WlX|$|zsC+o6twO{oOe@x5nAndz-XADWP6(xtRm`mP?soTt z3m1JG=zbMJWyBooypWCIa^S-)98J0f}ao5J%Y_TXK=r%7&Wrf)(7LNB}T)Oq`d;QqFR+T7KFC)77 z6I}#P_>d20{=qa#Tn~_!l?Jq!voAMk1!md3Z+S}^PA6&2a2jejh>C^VaH$8vOpm6lq zu|nT)Vv-S)+21;Rt9Ld{W+$^q9Zg2=KYp7QAA9R!M;04Ae%Q{LE+F};l}p_{M|3Id zA7YoQ)1m3!ef#8?VWa}?L;EL`je`0^=3uBE;FHH7%A_&=QThky{iCza?GzQkX$Ok{ zgDp0L`J23WQ6hpq09q9>47Q(PLMaHSSXVP!fK@^YQCET&IZy%dyI{dVw=qMF5U#f$ z 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 literal 0 HcmV?d00001 diff --git a/benchmarks/results/pr325_rocm_mi300x/report.md b/benchmarks/results/pr325_rocm_mi300x/report.md new file mode 100644 index 00000000..0a0dfd1b --- /dev/null +++ b/benchmarks/results/pr325_rocm_mi300x/report.md @@ -0,0 +1,147 @@ +# PR #325 ROCm deterministic FFN performance analysis + +> Operator-only benchmark. No model checkpoint or serving engine was used. + +## Environment + +| Item | Value | +|---|---| +| NCCL_IB_DISABLE | 1 | +| architecture | gfx942:sramecc+:xnack- | +| git_commit | 7d04efe80f7903431bc75fff3bbbe85eb82e02c4 | +| gpu | AMD Instinct MI300X | +| gpu_count | 8 | +| hip | 7.14.60850 | +| native_collective | torch.distributed ProcessGroupNCCL (RCCL on ROCm) | +| native_gemm | torch.matmul (ROCm rocBLAS/hipBLASLt dispatch) | +| python | 3.12.3 | +| torch | 2.12.0+rocm7.14.0a20260608 | + +## Methodology + +- BF16 operator inputs; FFN dimensions are H=4096 and I=12288. +- Native GEMM is `torch.matmul`; native communication calls PyTorch's ProcessGroupNCCL directly, which uses RCCL on ROCm. +- The native distributed FFN uses the same weights, TP/CP/SP sharding, and collective schedule as the deterministic path. +- Single-GPU timing: GPU events, median and p95; distributed timing: synchronized wall clock, slowest rank per sample. +- 5 warmups, 20 measured forward/collective samples, and 10 measured forward+backward samples. +- `NCCL_IB_DISABLE=1` selects the same intra-node XGMI transport for both collective implementations. Raw median, p95, minimum, and maximum measurements are in `results.json`. + +Reproduce this report from the repository root: + +```bash +python benchmarks/benchmark_rocm_ffn.py \ + --warmup 5 \ + --samples 20 \ + --training-samples 10 \ + --output-dir benchmarks/results/pr325_rocm_mi300x +``` + +## Key findings + +- The gfx942 deterministic GEMM scalar fallback costs 44.0-1109.8x native latency. This dominates end-to-end FFN overhead. +- The fused deterministic SwiGLU costs 0.22-0.76x native latency, so it is faster than the unfused PyTorch expression; it is not the bottleneck. +- Deterministic collectives cost 2.0-27.6x native RCCL latency across 2/4/8 ranks and 64 KiB/1 MiB/16 MiB per rank. +- Distributed FFN overhead is 32.1-105.8x for forward and 11.7-61.0x for forward+backward. +- All 16 distributed direction/topology cases are train/inference and repeat bitwise consistent: yes. +- GEMM relative-L2 error against FP32 is 0.500-0.577% for the deterministic BF16 tree versus 0.164-0.166% for native ROCm. The fixed BF16 tree buys topology invariance, not better FP32 proximity. +- Distributed FFN output drift versus native is 1.012-1.060% relative-L2. Conversely, the balanced deterministic reduction is closer to FP32 than native RCCL in 12/12 tested 4/8-rank reduction cases. + +## Single-GPU GEMM + +| Shape | Native ROCm (ms) | Deterministic (ms) | Overhead | Det rel-L2 vs FP32 | Native rel-L2 vs FP32 | +|---|---:|---:|---:|---:|---:| +| gate_up_m1 | 0.0384 | 1.6887 | 44.0× | 5.003e-03 | 1.651e-03 | +| down_m1 | 0.0283 | 4.8950 | 173.2× | 5.769e-03 | 1.635e-03 | +| gate_up_m8 | 0.0297 | 3.1275 | 105.4× | 5.018e-03 | 1.663e-03 | +| down_m8 | 0.0299 | 6.3458 | 211.9× | 5.679e-03 | 1.654e-03 | +| gate_up_m32 | 0.0318 | 12.9507 | 406.9× | 5.019e-03 | 1.654e-03 | +| down_m32 | 0.0295 | 16.5279 | 560.6× | 5.604e-03 | 1.662e-03 | +| gate_up_m128 | 0.0533 | 45.9833 | 862.7× | 5.019e-03 | 1.657e-03 | +| down_m128 | 0.0550 | 61.0427 | 1109.8× | 5.623e-03 | 1.659e-03 | + +## Single-GPU SwiGLU + +| Case | Native PyTorch (ms) | Deterministic fused (ms) | Det/native | Det/native rel-L2 | +|---|---:|---:|---:|---:| +| swiglu_forward_m1 | 0.0168 | 0.0127 | 0.76x | 2.877e-03 | +| swiglu_backward_m1 | 0.0562 | 0.0141 | 0.25x | 5.159e-03 | +| swiglu_forward_m8 | 0.0190 | 0.0129 | 0.68x | 2.816e-03 | +| swiglu_backward_m8 | 0.0676 | 0.0146 | 0.22x | 5.074e-03 | +| swiglu_forward_m32 | 0.0200 | 0.0136 | 0.68x | 2.825e-03 | +| swiglu_backward_m32 | 0.0706 | 0.0156 | 0.22x | 5.071e-03 | +| swiglu_forward_m128 | 0.0203 | 0.0134 | 0.66x | 2.828e-03 | +| swiglu_backward_m128 | 0.0669 | 0.0149 | 0.22x | 5.059e-03 | + +## Single-GPU FFN + +| Case | Native ROCm (ms) | Deterministic (ms) | Overhead | Output rel-L2 | Max grad rel-L2 | +|---|---:|---:|---:|---:|---:| +| ffn_forward_m1 | 0.0929 | 9.4786 | 102.0× | 1.008e-02 | nan | +| ffn_train_fwd_bwd_m1 | 0.4308 | 39.0465 | 90.6× | 1.008e-02 | 1.037e-02 | +| ffn_forward_m8 | 0.1018 | 14.0304 | 137.8× | 9.930e-03 | nan | +| ffn_train_fwd_bwd_m8 | 0.4067 | 47.4899 | 116.8× | 9.930e-03 | 1.017e-02 | +| ffn_forward_m32 | 0.1120 | 43.5693 | 388.9× | 9.952e-03 | nan | +| ffn_train_fwd_bwd_m32 | 0.5347 | 107.4444 | 200.9× | 9.952e-03 | 1.024e-02 | + +## RCCL collectives + +| Operation | Ranks | Input/rank | Native RCCL (ms) | Deterministic (ms) | Overhead | Det/native rel-L2 | Native/FP32 rel-L2 | Det/FP32 rel-L2 | +|---|---:|---:|---:|---:|---:|---:|---:|---:| +| all_reduce | 2 | 0.0625 MiB | 0.0592 | 0.5532 | 9.3× | 0.000e+00 | 1.798e-03 | 1.798e-03 | +| all_gather | 2 | 0.0625 MiB | 0.0534 | 0.5392 | 10.1× | 0.000e+00 | 0.000e+00 | 0.000e+00 | +| reduce_scatter | 2 | 0.0625 MiB | 0.0523 | 0.5616 | 10.7× | 0.000e+00 | 1.804e-03 | 1.804e-03 | +| all_reduce | 2 | 1 MiB | 0.0825 | 0.5553 | 6.7× | 0.000e+00 | 1.800e-03 | 1.800e-03 | +| all_gather | 2 | 1 MiB | 0.0772 | 0.5586 | 7.2× | 0.000e+00 | 0.000e+00 | 0.000e+00 | +| reduce_scatter | 2 | 1 MiB | 0.0719 | 0.5781 | 8.0× | 0.000e+00 | 1.803e-03 | 1.803e-03 | +| all_reduce | 2 | 16 MiB | 0.5073 | 1.0212 | 2.0× | 0.000e+00 | 1.800e-03 | 1.800e-03 | +| all_gather | 2 | 16 MiB | 0.4099 | 1.2952 | 3.2× | 0.000e+00 | 0.000e+00 | 0.000e+00 | +| reduce_scatter | 2 | 16 MiB | 0.2442 | 0.8913 | 3.6× | 0.000e+00 | 1.803e-03 | 1.803e-03 | +| all_reduce | 4 | 0.0625 MiB | 0.0617 | 0.7073 | 11.5× | 3.221e-03 | 2.674e-03 | 2.536e-03 | +| all_gather | 4 | 0.0625 MiB | 0.0573 | 0.6558 | 11.4× | 0.000e+00 | 0.000e+00 | 0.000e+00 | +| reduce_scatter | 4 | 0.0625 MiB | 0.0559 | 0.7087 | 12.7× | 3.263e-03 | 2.734e-03 | 2.559e-03 | +| all_reduce | 4 | 1 MiB | 0.0874 | 0.6935 | 7.9× | 3.256e-03 | 2.682e-03 | 2.566e-03 | +| all_gather | 4 | 1 MiB | 0.0883 | 0.6794 | 7.7× | 0.000e+00 | 0.000e+00 | 0.000e+00 | +| reduce_scatter | 4 | 1 MiB | 0.0908 | 0.7014 | 7.7× | 3.319e-03 | 2.691e-03 | 2.599e-03 | +| all_reduce | 4 | 16 MiB | 0.2442 | 1.0390 | 4.3× | 3.256e-03 | 2.682e-03 | 2.566e-03 | +| all_gather | 4 | 16 MiB | 0.4244 | 1.0259 | 2.4× | 0.000e+00 | 0.000e+00 | 0.000e+00 | +| reduce_scatter | 4 | 16 MiB | 0.1556 | 1.0519 | 6.8× | 3.319e-03 | 2.691e-03 | 2.599e-03 | +| all_reduce | 8 | 0.0625 MiB | 0.0374 | 1.0311 | 27.6× | 4.446e-03 | 3.664e-03 | 3.099e-03 | +| all_gather | 8 | 0.0625 MiB | 0.0721 | 0.9555 | 13.2× | 0.000e+00 | 0.000e+00 | 0.000e+00 | +| reduce_scatter | 8 | 0.0625 MiB | 0.0670 | 1.0387 | 15.5× | 4.879e-03 | 3.780e-03 | 3.155e-03 | +| all_reduce | 8 | 1 MiB | 0.0545 | 1.0036 | 18.4× | 4.474e-03 | 3.676e-03 | 3.110e-03 | +| all_gather | 8 | 1 MiB | 0.0887 | 0.9689 | 10.9× | 0.000e+00 | 0.000e+00 | 0.000e+00 | +| reduce_scatter | 8 | 1 MiB | 0.0669 | 1.0162 | 15.2× | 4.765e-03 | 3.768e-03 | 3.168e-03 | +| all_reduce | 8 | 16 MiB | 0.1812 | 1.3730 | 7.6× | 4.474e-03 | 3.676e-03 | 3.110e-03 | +| all_gather | 8 | 16 MiB | 0.4353 | 1.3738 | 3.2× | 0.000e+00 | 0.000e+00 | 0.000e+00 | +| reduce_scatter | 8 | 16 MiB | 0.1228 | 1.5048 | 12.3× | 4.765e-03 | 3.768e-03 | 3.168e-03 | + +## Distributed FFN + +| Topology | Direction | Native ROCm/RCCL (ms) | Deterministic (ms) | Overhead | Output rel-L2 | Max grad rel-L2 | Train/infer bitwise | Repeat bitwise | +|---|---|---:|---:|---:|---:|---:|:---:|:---:| +| tp2 | forward | 0.2170 | 22.9695 | 105.8× | 1.012e-02 | nan | yes | yes | +| tp2 | train_fwd_bwd | 0.9359 | 57.1264 | 61.0× | 1.012e-02 | 1.079e-02 | yes | yes | +| tp2_sp | forward | 0.2821 | 23.6457 | 83.8× | 1.015e-02 | nan | yes | yes | +| tp2_sp | train_fwd_bwd | 1.0045 | 58.6581 | 58.4× | 1.015e-02 | 1.083e-02 | yes | yes | +| tp4 | forward | 0.2175 | 13.6428 | 62.7× | 1.031e-02 | nan | yes | yes | +| tp4 | train_fwd_bwd | 1.1884 | 33.2462 | 28.0× | 1.031e-02 | 1.095e-02 | yes | yes | +| tp2_cp2 | forward | 0.2231 | 14.1083 | 63.2× | 1.015e-02 | nan | yes | yes | +| tp2_cp2 | train_fwd_bwd | 1.2568 | 43.0444 | 34.2× | 1.015e-02 | 1.083e-02 | yes | yes | +| tp2_cp2_sp | forward | 0.2819 | 14.7152 | 52.2× | 1.022e-02 | nan | yes | yes | +| tp2_cp2_sp | train_fwd_bwd | 1.3499 | 44.1678 | 32.7× | 1.022e-02 | 1.089e-02 | yes | yes | +| tp8 | forward | 0.1939 | 8.2995 | 42.8× | 1.060e-02 | nan | yes | yes | +| tp8 | train_fwd_bwd | 1.0345 | 20.4734 | 19.8× | 1.060e-02 | 1.126e-02 | yes | yes | +| tp4_cp2 | forward | 0.2230 | 8.4606 | 37.9× | 1.033e-02 | nan | yes | yes | +| tp4_cp2 | train_fwd_bwd | 2.1949 | 25.7398 | 11.7× | 1.033e-02 | 1.099e-02 | yes | yes | +| tp4_cp2_sp | forward | 0.2846 | 9.1342 | 32.1× | 1.045e-02 | nan | yes | yes | +| tp4_cp2_sp | train_fwd_bwd | 2.0314 | 26.6942 | 13.1× | 1.045e-02 | 1.109e-02 | yes | yes | + +## Figures + +![Single-GPU overhead](single_gpu_overhead.png) + +![RCCL collective overhead](collective_overhead.png) + +![Distributed FFN overhead](distributed_ffn_overhead.png) + +![Accuracy trade-off](accuracy_tradeoff.png) diff --git a/benchmarks/results/pr325_rocm_mi300x/results.json b/benchmarks/results/pr325_rocm_mi300x/results.json new file mode 100644 index 00000000..77f72fa3 --- /dev/null +++ b/benchmarks/results/pr325_rocm_mi300x/results.json @@ -0,0 +1,1859 @@ +{ + "collectives": [ + { + "deterministic": { + "max_ms": 0.6261998787522316, + "median_ms": 0.5532021168619394, + "min_ms": 0.5368776619434357, + "p95_ms": 0.6180185358971357 + }, + "deterministic_vs_fp32_relative_l2": 0.0017977143870666623, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 65536, + "native": { + "max_ms": 0.07622316479682922, + "median_ms": 0.05916808731853962, + "min_ms": 0.05741463974118233, + "p95_ms": 0.06484475452452898 + }, + "native_vs_fp32_relative_l2": 0.0017977143870666623, + "operation": "all_reduce", + "overhead_ratio": 9.349670437776684, + "world_size": 2 + }, + { + "deterministic": { + "max_ms": 0.5761669017374516, + "median_ms": 0.5391959566622972, + "min_ms": 0.5236580036580563, + "p95_ms": 0.5545792868360877 + }, + "deterministic_vs_fp32_relative_l2": 0.0, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 65536, + "native": { + "max_ms": 0.06324425339698792, + "median_ms": 0.05340413190424442, + "min_ms": 0.0512758269906044, + "p95_ms": 0.059638870880007744 + }, + "native_vs_fp32_relative_l2": 0.0, + "operation": "all_gather", + "overhead_ratio": 10.096521325898443, + "world_size": 2 + }, + { + "deterministic": { + "max_ms": 2.406816929578781, + "median_ms": 0.5615742411464453, + "min_ms": 0.5493457429111004, + "p95_ms": 2.3637562757357955 + }, + "deterministic_vs_fp32_relative_l2": 0.0018041146686300635, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 65536, + "native": { + "max_ms": 0.05941838026046753, + "median_ms": 0.05228794179856777, + "min_ms": 0.0500241294503212, + "p95_ms": 0.05908571183681488 + }, + "native_vs_fp32_relative_l2": 0.0018041146686300635, + "operation": "reduce_scatter", + "overhead_ratio": 10.740033396415452, + "world_size": 2 + }, + { + "deterministic": { + "max_ms": 0.5880738608539104, + "median_ms": 0.5553208757191896, + "min_ms": 0.5413354374468327, + "p95_ms": 0.5869807442650199 + }, + "deterministic_vs_fp32_relative_l2": 0.0018001609714701772, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 1048576, + "native": { + "max_ms": 0.09050499647855759, + "median_ms": 0.0825272873044014, + "min_ms": 0.07984880357980728, + "p95_ms": 0.08577597327530385 + }, + "native_vs_fp32_relative_l2": 0.0018001609714701772, + "operation": "all_reduce", + "overhead_ratio": 6.728936499159266, + "world_size": 2 + }, + { + "deterministic": { + "max_ms": 64.35962300747633, + "median_ms": 0.5586401093751192, + "min_ms": 0.5417549982666969, + "p95_ms": 57.14892167598009 + }, + "deterministic_vs_fp32_relative_l2": 0.0, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 1048576, + "native": { + "max_ms": 12.254353147000074, + "median_ms": 0.07722945883870125, + "min_ms": 0.07402012124657631, + "p95_ms": 6.211437424644832 + }, + "native_vs_fp32_relative_l2": 0.0, + "operation": "all_gather", + "overhead_ratio": 7.233510603018408, + "world_size": 2 + }, + { + "deterministic": { + "max_ms": 0.5999617278575897, + "median_ms": 0.5781142972409725, + "min_ms": 0.5616350099444389, + "p95_ms": 0.5963262636214495 + }, + "deterministic_vs_fp32_relative_l2": 0.0018025875324383378, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 1048576, + "native": { + "max_ms": 0.0805300660431385, + "median_ms": 0.0718564260751009, + "min_ms": 0.0688033178448677, + "p95_ms": 0.08022615220397711 + }, + "native_vs_fp32_relative_l2": 0.0018025875324383378, + "operation": "reduce_scatter", + "overhead_ratio": 8.045408445957987, + "world_size": 2 + }, + { + "deterministic": { + "max_ms": 2.6921010576188564, + "median_ms": 1.0212473571300507, + "min_ms": 0.8769533596932888, + "p95_ms": 1.8488724250346429 + }, + "deterministic_vs_fp32_relative_l2": 0.0018001609714701772, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 16777216, + "native": { + "max_ms": 1.5974435955286026, + "median_ms": 0.507319113239646, + "min_ms": 0.40442077443003654, + "p95_ms": 1.5856754500418901 + }, + "native_vs_fp32_relative_l2": 0.0018001609714701772, + "operation": "all_reduce", + "overhead_ratio": 2.01302756091438, + "world_size": 2 + }, + { + "deterministic": { + "max_ms": 10.63810009509325, + "median_ms": 1.2951798271387815, + "min_ms": 0.8751596324145794, + "p95_ms": 9.724058653227985 + }, + "deterministic_vs_fp32_relative_l2": 0.0, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 16777216, + "native": { + "max_ms": 0.7870900444686413, + "median_ms": 0.4098694771528244, + "min_ms": 0.4048221744596958, + "p95_ms": 0.7870710222050548 + }, + "native_vs_fp32_relative_l2": 0.0, + "operation": "all_gather", + "overhead_ratio": 3.1599811631151526, + "world_size": 2 + }, + { + "deterministic": { + "max_ms": 34.49406614527106, + "median_ms": 0.8912745397537947, + "min_ms": 0.8777636103332043, + "p95_ms": 34.13308993913233 + }, + "deterministic_vs_fp32_relative_l2": 0.0018025875324383378, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 16777216, + "native": { + "max_ms": 38.9344347640872, + "median_ms": 0.24419790133833885, + "min_ms": 0.24136900901794434, + "p95_ms": 38.81874312646687 + }, + "native_vs_fp32_relative_l2": 0.0018025875324383378, + "operation": "reduce_scatter", + "overhead_ratio": 3.6498042565850066, + "world_size": 2 + }, + { + "deterministic": { + "max_ms": 2.2844448685646057, + "median_ms": 0.7072966545820236, + "min_ms": 0.6777471862733364, + "p95_ms": 1.7822416266426446 + }, + "deterministic_vs_fp32_relative_l2": 0.0025360193103551865, + "deterministic_vs_native": { + "exact_fraction": 0.634796142578125, + "max_abs": 0.0625, + "relative_l2": 0.0032213402446359396 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 65536, + "native": { + "max_ms": 0.08035963401198387, + "median_ms": 0.061666592955589294, + "min_ms": 0.05907798185944557, + "p95_ms": 0.07251007482409477 + }, + "native_vs_fp32_relative_l2": 0.002674481365829706, + "operation": "all_reduce", + "overhead_ratio": 11.469689189597366, + "world_size": 4 + }, + { + "deterministic": { + "max_ms": 1.678945031017065, + "median_ms": 0.655770068988204, + "min_ms": 0.6485441699624062, + "p95_ms": 1.543825468979776 + }, + "deterministic_vs_fp32_relative_l2": 0.0, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 65536, + "native": { + "max_ms": 0.09300792589783669, + "median_ms": 0.05731009878218174, + "min_ms": 0.055382028222084045, + "p95_ms": 0.08073502685874702 + }, + "native_vs_fp32_relative_l2": 0.0, + "operation": "all_gather", + "overhead_ratio": 11.442487151882021, + "world_size": 4 + }, + { + "deterministic": { + "max_ms": 0.7582269608974457, + "median_ms": 0.7087434642016888, + "min_ms": 0.6915181875228882, + "p95_ms": 0.7377718342468143 + }, + "deterministic_vs_fp32_relative_l2": 0.0025591703597456217, + "deterministic_vs_native": { + "exact_fraction": 0.627197265625, + "max_abs": 0.0625, + "relative_l2": 0.0032631719950586557 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 65536, + "native": { + "max_ms": 0.0782073475420475, + "median_ms": 0.05585351027548313, + "min_ms": 0.05363998934626579, + "p95_ms": 0.06395436357706787 + }, + "native_vs_fp32_relative_l2": 0.002734305104240775, + "operation": "reduce_scatter", + "overhead_ratio": 12.689327147138885, + "world_size": 4 + }, + { + "deterministic": { + "max_ms": 3.081770148128271, + "median_ms": 0.6935065612196922, + "min_ms": 0.6749131716787815, + "p95_ms": 3.046196303330362 + }, + "deterministic_vs_fp32_relative_l2": 0.0025664919521659613, + "deterministic_vs_native": { + "exact_fraction": 0.6364593505859375, + "max_abs": 0.0625, + "relative_l2": 0.0032560781110078096 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 1048576, + "native": { + "max_ms": 0.0993083231151104, + "median_ms": 0.08740485645830631, + "min_ms": 0.08559692651033401, + "p95_ms": 0.09218205232173204 + }, + "native_vs_fp32_relative_l2": 0.002681644633412361, + "operation": "all_reduce", + "overhead_ratio": 7.934416796971772, + "world_size": 4 + }, + { + "deterministic": { + "max_ms": 18.371073994785547, + "median_ms": 0.6793595384806395, + "min_ms": 0.6663505919277668, + "p95_ms": 16.161395655944947 + }, + "deterministic_vs_fp32_relative_l2": 0.0, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 1048576, + "native": { + "max_ms": 0.10699918493628502, + "median_ms": 0.08834153413772583, + "min_ms": 0.08699903264641762, + "p95_ms": 0.09641882497817278 + }, + "native_vs_fp32_relative_l2": 0.0, + "operation": "all_gather", + "overhead_ratio": 7.69014875179219, + "world_size": 4 + }, + { + "deterministic": { + "max_ms": 1.1396128684282303, + "median_ms": 0.7014276925474405, + "min_ms": 0.692478846758604, + "p95_ms": 0.7431495236232879 + }, + "deterministic_vs_fp32_relative_l2": 0.0025991499423980713, + "deterministic_vs_native": { + "exact_fraction": 0.6246337890625, + "max_abs": 0.0625, + "relative_l2": 0.003319077892228961 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 1048576, + "native": { + "max_ms": 0.11748401448130608, + "median_ms": 0.09075016714632511, + "min_ms": 0.08760020136833191, + "p95_ms": 0.0971912406384945 + }, + "native_vs_fp32_relative_l2": 0.0026913494803011417, + "operation": "reduce_scatter", + "overhead_ratio": 7.729216535948216, + "world_size": 4 + }, + { + "deterministic": { + "max_ms": 1.0757180862128735, + "median_ms": 1.0390393435955048, + "min_ms": 1.0298010893166065, + "p95_ms": 1.0595633182674646 + }, + "deterministic_vs_fp32_relative_l2": 0.0025664919521659613, + "deterministic_vs_native": { + "exact_fraction": 0.6364593505859375, + "max_abs": 0.0625, + "relative_l2": 0.0032560781110078096 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 16777216, + "native": { + "max_ms": 7.769768126308918, + "median_ms": 0.24415762163698673, + "min_ms": 0.23796269670128822, + "p95_ms": 7.741929264739156 + }, + "native_vs_fp32_relative_l2": 0.002681644633412361, + "operation": "all_reduce", + "overhead_ratio": 4.255608883430013, + "world_size": 4 + }, + { + "deterministic": { + "max_ms": 1.0499609634280205, + "median_ms": 1.0259200353175402, + "min_ms": 1.019003801047802, + "p95_ms": 1.0489806532859802 + }, + "deterministic_vs_fp32_relative_l2": 0.0, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 16777216, + "native": { + "max_ms": 0.46255672350525856, + "median_ms": 0.42436597868800163, + "min_ms": 0.4211859777569771, + "p95_ms": 0.45994094107300043 + }, + "native_vs_fp32_relative_l2": 0.0, + "operation": "all_gather", + "overhead_ratio": 2.417536010990663, + "world_size": 4 + }, + { + "deterministic": { + "max_ms": 2.8247181326150894, + "median_ms": 1.0518885683268309, + "min_ms": 1.0401061736047268, + "p95_ms": 1.8256383249536163 + }, + "deterministic_vs_fp32_relative_l2": 0.0025991499423980713, + "deterministic_vs_native": { + "exact_fraction": 0.6246337890625, + "max_abs": 0.0625, + "relative_l2": 0.003319077892228961 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 16777216, + "native": { + "max_ms": 0.18415367230772972, + "median_ms": 0.15562609769403934, + "min_ms": 0.15309778973460197, + "p95_ms": 0.16564899124205115 + }, + "native_vs_fp32_relative_l2": 0.0026913494803011417, + "operation": "reduce_scatter", + "overhead_ratio": 6.759075655773636, + "world_size": 4 + }, + { + "deterministic": { + "max_ms": 1.3878229074180126, + "median_ms": 1.0311424266546965, + "min_ms": 0.9966720826923847, + "p95_ms": 1.1172502301633358 + }, + "deterministic_vs_fp32_relative_l2": 0.003098697867244482, + "deterministic_vs_native": { + "exact_fraction": 0.474761962890625, + "max_abs": 0.09375, + "relative_l2": 0.004446270409971476 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 65536, + "native": { + "max_ms": 0.07743481546640396, + "median_ms": 0.0373858492821455, + "min_ms": 0.03410130739212036, + "p95_ms": 0.04556367639452222 + }, + "native_vs_fp32_relative_l2": 0.00366417970508337, + "operation": "all_reduce", + "overhead_ratio": 27.58108873956069, + "world_size": 8 + }, + { + "deterministic": { + "max_ms": 1.0915519669651985, + "median_ms": 0.9554806165397167, + "min_ms": 0.9445939213037491, + "p95_ms": 1.0771007975563407 + }, + "deterministic_vs_fp32_relative_l2": 0.0, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 65536, + "native": { + "max_ms": 0.09826617315411568, + "median_ms": 0.07212720811367035, + "min_ms": 0.06782123818993568, + "p95_ms": 0.09462186135351658 + }, + "native_vs_fp32_relative_l2": 0.0, + "operation": "all_gather", + "overhead_ratio": 13.247159311003797, + "world_size": 8 + }, + { + "deterministic": { + "max_ms": 2.526514697819948, + "median_ms": 1.038714312016964, + "min_ms": 1.0141967795789242, + "p95_ms": 1.173690240830184 + }, + "deterministic_vs_fp32_relative_l2": 0.00315469061024487, + "deterministic_vs_native": { + "exact_fraction": 0.416015625, + "max_abs": 0.09375, + "relative_l2": 0.0048787277191877365 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 65536, + "native": { + "max_ms": 0.10104989632964134, + "median_ms": 0.06698444485664368, + "min_ms": 0.06429525092244148, + "p95_ms": 0.07444880902767183 + }, + "native_vs_fp32_relative_l2": 0.003779719350859523, + "operation": "reduce_scatter", + "overhead_ratio": 15.506798843223402, + "world_size": 8 + }, + { + "deterministic": { + "max_ms": 1.7048940062522888, + "median_ms": 1.003621844574809, + "min_ms": 0.9764907881617546, + "p95_ms": 1.6965883551165462 + }, + "deterministic_vs_fp32_relative_l2": 0.0031098078470677137, + "deterministic_vs_native": { + "exact_fraction": 0.476898193359375, + "max_abs": 0.125, + "relative_l2": 0.0044740429148077965 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 1048576, + "native": { + "max_ms": 0.08943211287260056, + "median_ms": 0.05449121817946434, + "min_ms": 0.050644855946302414, + "p95_ms": 0.08263099007308485 + }, + "native_vs_fp32_relative_l2": 0.003675796091556549, + "operation": "all_reduce", + "overhead_ratio": 18.418047496560387, + "world_size": 8 + }, + { + "deterministic": { + "max_ms": 2.1511665545403957, + "median_ms": 0.9689405560493469, + "min_ms": 0.9463569149374962, + "p95_ms": 1.615672581829131 + }, + "deterministic_vs_fp32_relative_l2": 0.0, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 1048576, + "native": { + "max_ms": 26.228610891848803, + "median_ms": 0.08868146687746048, + "min_ms": 0.08670799434185028, + "p95_ms": 26.1533159064129 + }, + "native_vs_fp32_relative_l2": 0.0, + "operation": "all_gather", + "overhead_ratio": 10.92607723086294, + "world_size": 8 + }, + { + "deterministic": { + "max_ms": 12.349193915724754, + "median_ms": 1.0162356775254011, + "min_ms": 1.0011079721152782, + "p95_ms": 1.8180392449721774 + }, + "deterministic_vs_fp32_relative_l2": 0.00316752796061337, + "deterministic_vs_native": { + "exact_fraction": 0.4222412109375, + "max_abs": 0.125, + "relative_l2": 0.0047652218490839005 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 1048576, + "native": { + "max_ms": 0.28899870812892914, + "median_ms": 0.06691413000226021, + "min_ms": 0.06446568295359612, + "p95_ms": 0.2850226126611233 + }, + "native_vs_fp32_relative_l2": 0.003768381429836154, + "operation": "reduce_scatter", + "overhead_ratio": 15.187161179426154, + "world_size": 8 + }, + { + "deterministic": { + "max_ms": 1.4179670251905918, + "median_ms": 1.3730006758123636, + "min_ms": 1.3582580722868443, + "p95_ms": 1.4027443481609227 + }, + "deterministic_vs_fp32_relative_l2": 0.0031098078470677137, + "deterministic_vs_native": { + "exact_fraction": 0.476898193359375, + "max_abs": 0.125, + "relative_l2": 0.0044740429148077965 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 16777216, + "native": { + "max_ms": 0.28833793476223946, + "median_ms": 0.18116971477866173, + "min_ms": 0.17664209008216858, + "p95_ms": 0.2745808567851782 + }, + "native_vs_fp32_relative_l2": 0.003675796091556549, + "operation": "all_reduce", + "overhead_ratio": 7.578533075960201, + "world_size": 8 + }, + { + "deterministic": { + "max_ms": 2.5825882330536842, + "median_ms": 1.3738316483795643, + "min_ms": 1.3334420509636402, + "p95_ms": 2.1614255849272017 + }, + "deterministic_vs_fp32_relative_l2": 0.0, + "deterministic_vs_native": { + "exact_fraction": 1.0, + "max_abs": 0.0, + "relative_l2": 0.0 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 16777216, + "native": { + "max_ms": 0.8975737728178501, + "median_ms": 0.4352864343672991, + "min_ms": 0.42576296254992485, + "p95_ms": 0.8845970500260592 + }, + "native_vs_fp32_relative_l2": 0.0, + "operation": "all_gather", + "overhead_ratio": 3.156155441362345, + "world_size": 8 + }, + { + "deterministic": { + "max_ms": 2.163366414606571, + "median_ms": 1.5047714114189148, + "min_ms": 1.3722190633416176, + "p95_ms": 2.075178758241236 + }, + "deterministic_vs_fp32_relative_l2": 0.00316752796061337, + "deterministic_vs_native": { + "exact_fraction": 0.4222412109375, + "max_abs": 0.125, + "relative_l2": 0.0047652218490839005 + }, + "dtype": "bfloat16", + "message_bytes_per_rank": 16777216, + "native": { + "max_ms": 0.706070102751255, + "median_ms": 0.12283260002732277, + "min_ms": 0.11617317795753479, + "p95_ms": 0.6168171996250749 + }, + "native_vs_fp32_relative_l2": 0.003768381429836154, + "operation": "reduce_scatter", + "overhead_ratio": 12.250586660904311, + "world_size": 8 + } + ], + "distributed_ffn": [ + { + "cp_size": 1, + "deterministic": { + "max_ms": 23.061915300786495, + "median_ms": 22.969487356022, + "min_ms": 22.887586150318384, + "p95_ms": 23.02536158822477 + }, + "direction": "forward", + "hidden": 4096, + "intermediate": 12288, + "name": "tp2", + "native": { + "max_ms": 0.25243498384952545, + "median_ms": 0.21701306104660034, + "min_ms": 0.2117040567100048, + "p95_ms": 0.23468146100640297 + }, + "output_max_abs": 3.814697265625e-05, + "output_relative_l2": 0.010115410201251507, + "overhead_ratio": 105.84380149860954, + "repeat_bitwise": true, + "sequence_parallel": false, + "tokens": 32, + "tp_size": 2, + "train_infer_bitwise": true, + "world_size": 2 + }, + { + "cp_size": 1, + "deterministic": { + "max_ms": 57.33681516721845, + "median_ms": 57.12637701071799, + "min_ms": 56.82690721005201, + "p95_ms": 57.29513259138912 + }, + "direction": "train_fwd_bwd", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.01079017948359251, + "name": "tp2", + "native": { + "max_ms": 1.1438699439167976, + "median_ms": 0.9358858224004507, + "min_ms": 0.86241215467453, + "p95_ms": 1.1243428336456418 + }, + "output_relative_l2": 0.010115410201251507, + "overhead_ratio": 61.03989999997512, + "repeat_bitwise": true, + "sequence_parallel": false, + "tokens": 32, + "tp_size": 2, + "train_infer_bitwise": true, + "world_size": 2 + }, + { + "cp_size": 1, + "deterministic": { + "max_ms": 23.713072296231985, + "median_ms": 23.645742563530803, + "min_ms": 23.4982930123806, + "p95_ms": 23.70628931093961 + }, + "direction": "forward", + "hidden": 4096, + "intermediate": 12288, + "name": "tp2_sp", + "native": { + "max_ms": 0.3683781251311302, + "median_ms": 0.28213439509272575, + "min_ms": 0.2738172188401222, + "p95_ms": 0.3154506674036384 + }, + "output_max_abs": 3.814697265625e-05, + "output_relative_l2": 0.010146456770598888, + "overhead_ratio": 83.81020880406814, + "repeat_bitwise": true, + "sequence_parallel": true, + "tokens": 32, + "tp_size": 2, + "train_infer_bitwise": true, + "world_size": 2 + }, + { + "cp_size": 1, + "deterministic": { + "max_ms": 58.87397890910506, + "median_ms": 58.658103458583355, + "min_ms": 58.49747033789754, + "p95_ms": 58.84236907586455 + }, + "direction": "train_fwd_bwd", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.010833753272891045, + "name": "tp2_sp", + "native": { + "max_ms": 1.0881680063903332, + "median_ms": 1.0044875089079142, + "min_ms": 0.9893607348203659, + "p95_ms": 1.0695371311157942 + }, + "output_relative_l2": 0.010146456770598888, + "overhead_ratio": 58.396050661054865, + "repeat_bitwise": true, + "sequence_parallel": true, + "tokens": 32, + "tp_size": 2, + "train_infer_bitwise": true, + "world_size": 2 + }, + { + "cp_size": 1, + "deterministic": { + "max_ms": 13.754431623965502, + "median_ms": 13.642776058986783, + "min_ms": 13.557879719883204, + "p95_ms": 13.735688501037657 + }, + "direction": "forward", + "hidden": 4096, + "intermediate": 12288, + "name": "tp4", + "native": { + "max_ms": 0.2563111484050751, + "median_ms": 0.2175336703658104, + "min_ms": 0.2123652957379818, + "p95_ms": 0.23448553401976827 + }, + "output_max_abs": 3.24249267578125e-05, + "output_relative_l2": 0.01030605100095272, + "overhead_ratio": 62.715698383816765, + "repeat_bitwise": true, + "sequence_parallel": false, + "tokens": 32, + "tp_size": 4, + "train_infer_bitwise": true, + "world_size": 4 + }, + { + "cp_size": 1, + "deterministic": { + "max_ms": 33.53102412074804, + "median_ms": 33.246190985664725, + "min_ms": 33.06937776505947, + "p95_ms": 33.47169344779104 + }, + "direction": "train_fwd_bwd", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.010952928103506565, + "name": "tp4", + "native": { + "max_ms": 1.3233372010290623, + "median_ms": 1.1884414125233889, + "min_ms": 0.8968831971287727, + "p95_ms": 1.3091185595840216 + }, + "output_relative_l2": 0.01030605100095272, + "overhead_ratio": 27.97461501705321, + "repeat_bitwise": true, + "sequence_parallel": false, + "tokens": 32, + "tp_size": 4, + "train_infer_bitwise": true, + "world_size": 4 + }, + { + "cp_size": 2, + "deterministic": { + "max_ms": 14.201576355844736, + "median_ms": 14.108308125287294, + "min_ms": 14.041068032383919, + "p95_ms": 14.17592593934387 + }, + "direction": "forward", + "hidden": 4096, + "intermediate": 12288, + "name": "tp2_cp2", + "native": { + "max_ms": 0.2589649520814419, + "median_ms": 0.2230664249509573, + "min_ms": 0.21581118926405907, + "p95_ms": 0.2376241842284799 + }, + "output_max_abs": 3.814697265625e-05, + "output_relative_l2": 0.010146137326955795, + "overhead_ratio": 63.24711631698542, + "repeat_bitwise": true, + "sequence_parallel": false, + "tokens": 32, + "tp_size": 2, + "train_infer_bitwise": true, + "world_size": 4 + }, + { + "cp_size": 2, + "deterministic": { + "max_ms": 44.00618327781558, + "median_ms": 43.04443299770355, + "min_ms": 42.86633804440498, + "p95_ms": 43.58996688388288 + }, + "direction": "train_fwd_bwd", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.010834906250238419, + "name": "tp2_cp2", + "native": { + "max_ms": 1.2799520045518875, + "median_ms": 1.2568281963467598, + "min_ms": 1.2058420106768608, + "p95_ms": 1.2796366354450583 + }, + "output_relative_l2": 0.010146137326955795, + "overhead_ratio": 34.248462218480945, + "repeat_bitwise": true, + "sequence_parallel": false, + "tokens": 32, + "tp_size": 2, + "train_infer_bitwise": true, + "world_size": 4 + }, + { + "cp_size": 2, + "deterministic": { + "max_ms": 15.157598070800304, + "median_ms": 14.71517514437437, + "min_ms": 14.627058990299702, + "p95_ms": 14.986694976687431 + }, + "direction": "forward", + "hidden": 4096, + "intermediate": 12288, + "name": "tp2_cp2_sp", + "native": { + "max_ms": 0.355488620698452, + "median_ms": 0.2818985376507044, + "min_ms": 0.27362629771232605, + "p95_ms": 0.29898409266024834 + }, + "output_max_abs": 3.814697265625e-05, + "output_relative_l2": 0.010219351388514042, + "overhead_ratio": 52.20025356288897, + "repeat_bitwise": true, + "sequence_parallel": true, + "tokens": 32, + "tp_size": 2, + "train_infer_bitwise": true, + "world_size": 4 + }, + { + "cp_size": 2, + "deterministic": { + "max_ms": 44.428070075809956, + "median_ms": 44.167807791382074, + "min_ms": 44.01867091655731, + "p95_ms": 44.36768894083798 + }, + "direction": "train_fwd_bwd", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.010887548327445984, + "name": "tp2_cp2_sp", + "native": { + "max_ms": 2.3635230027139187, + "median_ms": 1.3499259948730469, + "min_ms": 1.3143029063940048, + "p95_ms": 2.188203553669154 + }, + "output_relative_l2": 0.010219351388514042, + "overhead_ratio": 32.718688253377785, + "repeat_bitwise": true, + "sequence_parallel": true, + "tokens": 32, + "tp_size": 2, + "train_infer_bitwise": true, + "world_size": 4 + }, + { + "cp_size": 1, + "deterministic": { + "max_ms": 8.542937226593494, + "median_ms": 8.299475070089102, + "min_ms": 8.264432195574045, + "p95_ms": 8.351644920185208 + }, + "direction": "forward", + "hidden": 4096, + "intermediate": 12288, + "name": "tp8", + "native": { + "max_ms": 0.23235473781824112, + "median_ms": 0.19394350238144398, + "min_ms": 0.18893089145421982, + "p95_ms": 0.22797829005867243 + }, + "output_max_abs": 3.814697265625e-05, + "output_relative_l2": 0.01060183160007, + "overhead_ratio": 42.79326179108527, + "repeat_bitwise": true, + "sequence_parallel": false, + "tokens": 32, + "tp_size": 8, + "train_infer_bitwise": true, + "world_size": 8 + }, + { + "cp_size": 1, + "deterministic": { + "max_ms": 20.56828886270523, + "median_ms": 20.47342318110168, + "min_ms": 20.433178171515465, + "p95_ms": 20.554989716038108 + }, + "direction": "train_fwd_bwd", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.011263994500041008, + "name": "tp8", + "native": { + "max_ms": 1.0906010866165161, + "median_ms": 1.0344625916332006, + "min_ms": 0.7926779799163342, + "p95_ms": 1.0858194204047322 + }, + "output_relative_l2": 0.01060183160007, + "overhead_ratio": 19.79136156946808, + "repeat_bitwise": true, + "sequence_parallel": false, + "tokens": 32, + "tp_size": 8, + "train_infer_bitwise": true, + "world_size": 8 + }, + { + "cp_size": 2, + "deterministic": { + "max_ms": 8.510307874530554, + "median_ms": 8.460600161924958, + "min_ms": 8.43221228569746, + "p95_ms": 8.489186526276171 + }, + "direction": "forward", + "hidden": 4096, + "intermediate": 12288, + "name": "tp4_cp2", + "native": { + "max_ms": 0.4084971733391285, + "median_ms": 0.22301147691905499, + "min_ms": 0.21689198911190033, + "p95_ms": 0.3945016534999013 + }, + "output_max_abs": 3.24249267578125e-05, + "output_relative_l2": 0.010326871648430824, + "overhead_ratio": 37.937958524869316, + "repeat_bitwise": true, + "sequence_parallel": false, + "tokens": 32, + "tp_size": 4, + "train_infer_bitwise": true, + "world_size": 8 + }, + { + "cp_size": 2, + "deterministic": { + "max_ms": 27.1592540666461, + "median_ms": 25.739769218489528, + "min_ms": 25.42050974443555, + "p95_ms": 26.866142894141376 + }, + "direction": "train_fwd_bwd", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.010986514389514923, + "name": "tp4_cp2", + "native": { + "max_ms": 2.3030731827020645, + "median_ms": 2.1949070505797863, + "min_ms": 2.0920690149068832, + "p95_ms": 2.2968946723267436 + }, + "output_relative_l2": 0.010326871648430824, + "overhead_ratio": 11.727042934091605, + "repeat_bitwise": true, + "sequence_parallel": false, + "tokens": 32, + "tp_size": 4, + "train_infer_bitwise": true, + "world_size": 8 + }, + { + "cp_size": 2, + "deterministic": { + "max_ms": 10.612862650305033, + "median_ms": 9.134160354733467, + "min_ms": 9.08864801749587, + "p95_ms": 10.32724822871387 + }, + "direction": "forward", + "hidden": 4096, + "intermediate": 12288, + "name": "tp4_cp2_sp", + "native": { + "max_ms": 0.3657429479062557, + "median_ms": 0.28464803472161293, + "min_ms": 0.27577998116612434, + "p95_ms": 0.36119662690907717 + }, + "output_max_abs": 3.24249267578125e-05, + "output_relative_l2": 0.010454523377120495, + "overhead_ratio": 32.08931466421933, + "repeat_bitwise": true, + "sequence_parallel": true, + "tokens": 32, + "tp_size": 4, + "train_infer_bitwise": true, + "world_size": 8 + }, + { + "cp_size": 2, + "deterministic": { + "max_ms": 27.56996499374509, + "median_ms": 26.6941930167377, + "min_ms": 26.523639913648367, + "p95_ms": 27.54075217526406 + }, + "direction": "train_fwd_bwd", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.011090580374002457, + "name": "tp4_cp2_sp", + "native": { + "max_ms": 2.8670011088252068, + "median_ms": 2.031409414485097, + "min_ms": 2.0115189254283905, + "p95_ms": 2.801603823900223 + }, + "output_relative_l2": 0.010454523377120495, + "overhead_ratio": 13.140725265125297, + "repeat_bitwise": true, + "sequence_parallel": true, + "tokens": 32, + "tp_size": 4, + "train_infer_bitwise": true, + "world_size": 8 + } + ], + "environment": { + "NCCL_IB_DISABLE": "1", + "architecture": "gfx942:sramecc+:xnack-", + "git_commit": "7d04efe80f7903431bc75fff3bbbe85eb82e02c4", + "gpu": "AMD Instinct MI300X", + "gpu_count": 8, + "hip": "7.14.60850", + "native_collective": "torch.distributed ProcessGroupNCCL (RCCL on ROCm)", + "native_gemm": "torch.matmul (ROCm rocBLAS/hipBLASLt dispatch)", + "python": "3.12.3", + "torch": "2.12.0+rocm7.14.0a20260608" + }, + "methodology": { + "distributed_timing": "synchronized wall clock, slowest rank per sample", + "operator_only": true, + "samples": 20, + "single_gpu_timing": "GPU events, median and p95", + "training_samples": 10, + "warmup": 5 + }, + "single_gpu": { + "ffn": [ + { + "deterministic": { + "max_ms": 9.606557846069336, + "median_ms": 9.47858715057373, + "min_ms": 9.45252799987793, + "p95_ms": 9.512596654891967 + }, + "deterministic_vs_native": { + "exact_fraction": 0.170654296875, + "max_abs": 3.0517578125e-05, + "mean_abs": 5.4912252380745485e-06, + "relative_l2": 0.010084826499223709 + }, + "direction": "forward", + "dtype": "bfloat16", + "hidden": 4096, + "intermediate": 12288, + "name": "ffn_forward_m1", + "native": { + "max_ms": 0.1577949970960617, + "median_ms": 0.09291799739003181, + "min_ms": 0.09193699806928635, + "p95_ms": 0.10972879827022557 + }, + "overhead_ratio": 102.0102393165717, + "tokens": 1, + "train_infer_bitwise": null + }, + { + "deterministic": { + "max_ms": 39.23419189453125, + "median_ms": 39.04652976989746, + "min_ms": 39.02703857421875, + "p95_ms": 39.178144454956055 + }, + "deterministic_vs_native": { + "exact_fraction": 0.170654296875, + "max_abs": 3.0517578125e-05, + "mean_abs": 5.4912252380745485e-06, + "relative_l2": 0.010084826499223709 + }, + "direction": "train_fwd_bwd", + "dtype": "bfloat16", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.010372769087553024, + "name": "ffn_train_fwd_bwd_m1", + "native": { + "max_ms": 0.4987410008907318, + "median_ms": 0.4307605028152466, + "min_ms": 0.423429012298584, + "p95_ms": 0.4838869541883468 + }, + "overhead_ratio": 90.64556642196264, + "tokens": 1, + "train_infer_bitwise": true + }, + { + "deterministic": { + "max_ms": 14.115498542785645, + "median_ms": 14.030432224273682, + "min_ms": 13.932146072387695, + "p95_ms": 14.114965820312499 + }, + "deterministic_vs_native": { + "exact_fraction": 0.17657470703125, + "max_abs": 3.0517578125e-05, + "mean_abs": 5.513636097020935e-06, + "relative_l2": 0.009930303320288658 + }, + "direction": "forward", + "dtype": "bfloat16", + "hidden": 4096, + "intermediate": 12288, + "name": "ffn_forward_m8", + "native": { + "max_ms": 0.18122899532318115, + "median_ms": 0.1018114984035492, + "min_ms": 0.0950620025396347, + "p95_ms": 0.11554314792156224 + }, + "overhead_ratio": 137.80793372337376, + "tokens": 8, + "train_infer_bitwise": null + }, + { + "deterministic": { + "max_ms": 47.759178161621094, + "median_ms": 47.48986053466797, + "min_ms": 47.38426208496094, + "p95_ms": 47.67677898406983 + }, + "deterministic_vs_native": { + "exact_fraction": 0.17657470703125, + "max_abs": 3.0517578125e-05, + "mean_abs": 5.513636097020935e-06, + "relative_l2": 0.009930303320288658 + }, + "direction": "train_fwd_bwd", + "dtype": "bfloat16", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.010173660703003407, + "name": "ffn_train_fwd_bwd_m8", + "native": { + "max_ms": 0.6346229910850525, + "median_ms": 0.40674450993537903, + "min_ms": 0.3894589841365814, + "p95_ms": 0.5892494827508925 + }, + "overhead_ratio": 116.75599639245986, + "tokens": 8, + "train_infer_bitwise": true + }, + { + "deterministic": { + "max_ms": 43.82024383544922, + "median_ms": 43.569313049316406, + "min_ms": 43.464874267578125, + "p95_ms": 43.7121265411377 + }, + "deterministic_vs_native": { + "exact_fraction": 0.1738433837890625, + "max_abs": 3.4332275390625e-05, + "mean_abs": 5.583485290117096e-06, + "relative_l2": 0.009952187538146973 + }, + "direction": "forward", + "dtype": "bfloat16", + "hidden": 4096, + "intermediate": 12288, + "name": "ffn_forward_m32", + "native": { + "max_ms": 0.27404698729515076, + "median_ms": 0.11202599853277206, + "min_ms": 0.1095229983329773, + "p95_ms": 0.13137315176427375 + }, + "overhead_ratio": 388.92144341450035, + "tokens": 32, + "train_infer_bitwise": null + }, + { + "deterministic": { + "max_ms": 107.77581787109375, + "median_ms": 107.44444274902344, + "min_ms": 107.14933013916016, + "p95_ms": 107.69190292358398 + }, + "deterministic_vs_native": { + "exact_fraction": 0.1738433837890625, + "max_abs": 3.4332275390625e-05, + "mean_abs": 5.583485290117096e-06, + "relative_l2": 0.009952187538146973 + }, + "direction": "train_fwd_bwd", + "dtype": "bfloat16", + "hidden": 4096, + "intermediate": 12288, + "max_gradient_relative_l2": 0.010239087976515293, + "name": "ffn_train_fwd_bwd_m32", + "native": { + "max_ms": 0.6647080183029175, + "median_ms": 0.5346939861774445, + "min_ms": 0.40183699131011963, + "p95_ms": 0.6625448703765868 + }, + "overhead_ratio": 200.94567271487273, + "tokens": 32, + "train_infer_bitwise": true + } + ], + "gemm": [ + { + "deterministic": { + "max_ms": 1.697803020477295, + "median_ms": 1.6886900067329407, + "min_ms": 1.6718039512634277, + "p95_ms": 1.6968900084495544 + }, + "deterministic_vs_fp32": { + "exact_fraction": 0.0, + "max_abs": 0.0006177425384521484, + "mean_abs": 0.00010233040666207671, + "relative_l2": 0.0050025563687086105 + }, + "deterministic_vs_native": { + "exact_fraction": 0.3214518427848816, + "max_abs": 0.00048828125, + "mean_abs": 9.665884863352403e-05, + "relative_l2": 0.005253210663795471 + }, + "dtype": "bfloat16", + "k": 4096, + "m": 1, + "n": 12288, + "name": "gate_up_m1", + "native": { + "max_ms": 0.0579259991645813, + "median_ms": 0.038356998935341835, + "min_ms": 0.03673499822616577, + "p95_ms": 0.04266614820808173 + }, + "native_vs_fp32": { + "exact_fraction": 0.00016276042151730508, + "max_abs": 0.00024393200874328613, + "mean_abs": 2.9391663701971993e-05, + "relative_l2": 0.001651320606470108 + }, + "overhead_ratio": 44.02560298264093 + }, + { + "deterministic": { + "max_ms": 4.926641941070557, + "median_ms": 4.895015001296997, + "min_ms": 4.891510009765625, + "p95_ms": 4.9024379491806025 + }, + "deterministic_vs_fp32": { + "exact_fraction": 0.0, + "max_abs": 0.0010021775960922241, + "mean_abs": 0.00019940582569688559, + "relative_l2": 0.005768977105617523 + }, + "deterministic_vs_native": { + "exact_fraction": 0.282470703125, + "max_abs": 0.0009765625, + "mean_abs": 0.0001913216256070882, + "relative_l2": 0.006009528413414955 + }, + "dtype": "bfloat16", + "k": 12288, + "m": 1, + "n": 4096, + "name": "down_m1", + "native": { + "max_ms": 0.04602799937129021, + "median_ms": 0.0282619995996356, + "min_ms": 0.027079999446868896, + "p95_ms": 0.03693269956856967 + }, + "native_vs_fp32": { + "exact_fraction": 0.0, + "max_abs": 0.00047075748443603516, + "mean_abs": 4.846960655413568e-05, + "relative_l2": 0.001635060179978609 + }, + "overhead_ratio": 173.20129752461364 + }, + { + "deterministic": { + "max_ms": 3.1705520153045654, + "median_ms": 3.1275484561920166, + "min_ms": 3.1122660636901855, + "p95_ms": 3.1652623891830443 + }, + "deterministic_vs_fp32": { + "exact_fraction": 1.0172526344831567e-05, + "max_abs": 0.0007631853222846985, + "mean_abs": 0.00010021630441769958, + "relative_l2": 0.005017724819481373 + }, + "deterministic_vs_native": { + "exact_fraction": 0.315460205078125, + "max_abs": 0.0009765625, + "mean_abs": 9.520615276414901e-05, + "relative_l2": 0.005292810965329409 + }, + "dtype": "bfloat16", + "k": 4096, + "m": 8, + "n": 12288, + "name": "gate_up_m8", + "native": { + "max_ms": 0.04867300018668175, + "median_ms": 0.029683999717235565, + "min_ms": 0.02840299904346466, + "p95_ms": 0.03573305141180754 + }, + "native_vs_fp32": { + "exact_fraction": 9.1552734375e-05, + "max_abs": 0.0002437680959701538, + "mean_abs": 2.8738693799823523e-05, + "relative_l2": 0.0016632347833365202 + }, + "overhead_ratio": 105.36142319042177 + }, + { + "deterministic": { + "max_ms": 6.376195907592773, + "median_ms": 6.3458311557769775, + "min_ms": 6.335175037384033, + "p95_ms": 6.364094138145447 + }, + "deterministic_vs_fp32": { + "exact_fraction": 0.0, + "max_abs": 0.0011673420667648315, + "mean_abs": 0.00019835526472888887, + "relative_l2": 0.005679205991327763 + }, + "deterministic_vs_native": { + "exact_fraction": 0.282196044921875, + "max_abs": 0.001220703125, + "mean_abs": 0.0001906516554299742, + "relative_l2": 0.0059157246723771095 + }, + "dtype": "bfloat16", + "k": 12288, + "m": 8, + "n": 4096, + "name": "down_m8", + "native": { + "max_ms": 0.044505998492240906, + "median_ms": 0.02994500007480383, + "min_ms": 0.025036999955773354, + "p95_ms": 0.03735154997557402 + }, + "native_vs_fp32": { + "exact_fraction": 3.0517578125e-05, + "max_abs": 0.0004877448081970215, + "mean_abs": 5.014762427890673e-05, + "relative_l2": 0.0016539206262677908 + }, + "overhead_ratio": 211.91621772999943 + }, + { + "deterministic": { + "max_ms": 13.038738250732422, + "median_ms": 12.950687408447266, + "min_ms": 12.88098430633545, + "p95_ms": 13.009663200378418 + }, + "deterministic_vs_fp32": { + "exact_fraction": 1.780192178557627e-05, + "max_abs": 0.0008235722780227661, + "mean_abs": 0.00010053649748442695, + "relative_l2": 0.005019249860197306 + }, + "deterministic_vs_native": { + "exact_fraction": 0.31523895263671875, + "max_abs": 0.0009765625, + "mean_abs": 9.547884110361338e-05, + "relative_l2": 0.005280429497361183 + }, + "dtype": "bfloat16", + "k": 4096, + "m": 32, + "n": 12288, + "name": "gate_up_m32", + "native": { + "max_ms": 0.05364000052213669, + "median_ms": 0.031827500090003014, + "min_ms": 0.02980400063097477, + "p95_ms": 0.03955910168588162 + }, + "native_vs_fp32": { + "exact_fraction": 8.900960528990254e-05, + "max_abs": 0.00024408847093582153, + "mean_abs": 2.8744379960699007e-05, + "relative_l2": 0.001653508748859167 + }, + "overhead_ratio": 406.9024388288373 + }, + { + "deterministic": { + "max_ms": 16.65399169921875, + "median_ms": 16.527862548828125, + "min_ms": 16.420242309570312, + "p95_ms": 16.650489139556885 + }, + "deterministic_vs_fp32": { + "exact_fraction": 0.0, + "max_abs": 0.001408398151397705, + "mean_abs": 0.00019586752750910819, + "relative_l2": 0.005604307167232037 + }, + "deterministic_vs_native": { + "exact_fraction": 0.28676605224609375, + "max_abs": 0.00146484375, + "mean_abs": 0.0001877040631370619, + "relative_l2": 0.005841475911438465 + }, + "dtype": "bfloat16", + "k": 12288, + "m": 32, + "n": 4096, + "name": "down_m32", + "native": { + "max_ms": 0.045869000256061554, + "median_ms": 0.029483499936759472, + "min_ms": 0.027319999411702156, + "p95_ms": 0.03597379922866822 + }, + "native_vs_fp32": { + "exact_fraction": 7.62939453125e-06, + "max_abs": 0.0004875361919403076, + "mean_abs": 4.999893644708209e-05, + "relative_l2": 0.0016624650452286005 + }, + "overhead_ratio": 560.580073067292 + }, + { + "deterministic": { + "max_ms": 46.0939826965332, + "median_ms": 45.98331832885742, + "min_ms": 45.901615142822266, + "p95_ms": 46.07788867950439 + }, + "deterministic_vs_fp32": { + "exact_fraction": 3.1789145396032836e-06, + "max_abs": 0.000936552882194519, + "mean_abs": 0.0001006366073852405, + "relative_l2": 0.005018990952521563 + }, + "deterministic_vs_native": { + "exact_fraction": 0.3156604766845703, + "max_abs": 0.0009765625, + "mean_abs": 9.551996481604874e-05, + "relative_l2": 0.005280183628201485 + }, + "dtype": "bfloat16", + "k": 4096, + "m": 128, + "n": 12288, + "name": "gate_up_m128", + "native": { + "max_ms": 0.069582998752594, + "median_ms": 0.05329900048673153, + "min_ms": 0.050995998084545135, + "p95_ms": 0.05508409850299359 + }, + "native_vs_fp32": { + "exact_fraction": 5.53131103515625e-05, + "max_abs": 0.00024411827325820923, + "mean_abs": 2.880621286749374e-05, + "relative_l2": 0.0016574561595916748 + }, + "overhead_ratio": 862.7426013421151 + }, + { + "deterministic": { + "max_ms": 61.25751876831055, + "median_ms": 61.042701721191406, + "min_ms": 60.91461181640625, + "p95_ms": 61.23011798858643 + }, + "deterministic_vs_fp32": { + "exact_fraction": 1.9073486328125e-06, + "max_abs": 0.0016233325004577637, + "mean_abs": 0.00019636924844235182, + "relative_l2": 0.005622671451419592 + }, + "deterministic_vs_native": { + "exact_fraction": 0.2840576171875, + "max_abs": 0.001953125, + "mean_abs": 0.00018861530406866223, + "relative_l2": 0.005864132661372423 + }, + "dtype": "bfloat16", + "k": 12288, + "m": 128, + "n": 4096, + "name": "down_m128", + "native": { + "max_ms": 0.07434999942779541, + "median_ms": 0.05500099994242191, + "min_ms": 0.05331899970769882, + "p95_ms": 0.0570723481476307 + }, + "native_vs_fp32": { + "exact_fraction": 4.1961669921875e-05, + "max_abs": 0.0004882514476776123, + "mean_abs": 4.9878301069838926e-05, + "relative_l2": 0.0016591352177783847 + }, + "overhead_ratio": 1109.8471261448751 + } + ], + "swiglu": [ + { + "deterministic": { + "max_ms": 0.01726599968969822, + "median_ms": 0.012718500103801489, + "min_ms": 0.010174999944865704, + "p95_ms": 0.013841249933466318 + }, + "deterministic_vs_native": { + "exact_fraction": 0.7444661855697632, + "max_abs": 7.62939453125e-06, + "mean_abs": 1.8349970787312486e-07, + "relative_l2": 0.002877154853194952 + }, + "direction": "forward", + "dtype": "bfloat16", + "intermediate": 12288, + "name": "swiglu_forward_m1", + "native": { + "max_ms": 0.033969998359680176, + "median_ms": 0.016824999824166298, + "min_ms": 0.013900999911129475, + "p95_ms": 0.0220968995243311 + }, + "overhead_ratio": 0.7559286916326436, + "tokens": 1 + }, + { + "deterministic": { + "max_ms": 0.045586999505758286, + "median_ms": 0.014101000037044287, + "min_ms": 0.010294999927282333, + "p95_ms": 0.01974794939160349 + }, + "deterministic_vs_native": { + "max_abs": 1.52587890625e-05, + "relative_l2": 0.005158728454262018 + }, + "direction": "backward", + "dtype": "bfloat16", + "intermediate": 12288, + "name": "swiglu_backward_m1", + "native": { + "max_ms": 0.0824820026755333, + "median_ms": 0.05618349835276604, + "min_ms": 0.050154998898506165, + "p95_ms": 0.06737414933741093 + }, + "overhead_ratio": 0.25098116796691183, + "tokens": 1 + }, + { + "deterministic": { + "max_ms": 0.017985999584197998, + "median_ms": 0.012939500156790018, + "min_ms": 0.011737000197172165, + "p95_ms": 0.01494220029562712 + }, + "deterministic_vs_native": { + "exact_fraction": 0.739715576171875, + "max_abs": 7.62939453125e-06, + "mean_abs": 1.8075165542086324e-07, + "relative_l2": 0.002815817715600133 + }, + "direction": "forward", + "dtype": "bfloat16", + "intermediate": 12288, + "name": "swiglu_forward_m8", + "native": { + "max_ms": 0.02163200080394745, + "median_ms": 0.018968500196933746, + "min_ms": 0.016063999384641647, + "p95_ms": 0.021366000548005106 + }, + "overhead_ratio": 0.6821572619052763, + "tokens": 8 + }, + { + "deterministic": { + "max_ms": 0.029083000496029854, + "median_ms": 0.014560999814420938, + "min_ms": 0.012899000197649002, + "p95_ms": 0.01964569985866547 + }, + "deterministic_vs_native": { + "max_abs": 2.288818359375e-05, + "relative_l2": 0.005074448883533478 + }, + "direction": "backward", + "dtype": "bfloat16", + "intermediate": 12288, + "name": "swiglu_backward_m8", + "native": { + "max_ms": 0.09365999698638916, + "median_ms": 0.06756000220775604, + "min_ms": 0.06333400309085846, + "p95_ms": 0.07820824943482876 + }, + "overhead_ratio": 0.21552692922720632, + "tokens": 8 + }, + { + "deterministic": { + "max_ms": 0.017785999923944473, + "median_ms": 0.013599999714642763, + "min_ms": 0.011897999793291092, + "p95_ms": 0.014818200329318645 + }, + "deterministic_vs_native": { + "exact_fraction": 0.7368850708007812, + "max_abs": 1.52587890625e-05, + "mean_abs": 1.8277175684033864e-07, + "relative_l2": 0.002825492527335882 + }, + "direction": "forward", + "dtype": "bfloat16", + "intermediate": 12288, + "name": "swiglu_forward_m32", + "native": { + "max_ms": 0.031046999618411064, + "median_ms": 0.019969499669969082, + "min_ms": 0.01818699948489666, + "p95_ms": 0.023092649877071388 + }, + "overhead_ratio": 0.6810385808060568, + "tokens": 32 + }, + { + "deterministic": { + "max_ms": 0.03236899897456169, + "median_ms": 0.015602999832481146, + "min_ms": 0.01374099962413311, + "p95_ms": 0.03172109890729189 + }, + "deterministic_vs_native": { + "max_abs": 1.52587890625e-05, + "relative_l2": 0.0050712525844573975 + }, + "direction": "backward", + "dtype": "bfloat16", + "intermediate": 12288, + "name": "swiglu_backward_m32", + "native": { + "max_ms": 0.0897739976644516, + "median_ms": 0.07056549936532974, + "min_ms": 0.05820599943399429, + "p95_ms": 0.07546510063111783 + }, + "overhead_ratio": 0.22111371665779234, + "tokens": 32 + }, + { + "deterministic": { + "max_ms": 0.01826700009405613, + "median_ms": 0.013400000054389238, + "min_ms": 0.010816000401973724, + "p95_ms": 0.017582049965858458 + }, + "deterministic_vs_native": { + "exact_fraction": 0.7374452352523804, + "max_abs": 1.52587890625e-05, + "mean_abs": 1.8245665955873847e-07, + "relative_l2": 0.0028277577366679907 + }, + "direction": "forward", + "dtype": "bfloat16", + "intermediate": 12288, + "name": "swiglu_forward_m128", + "native": { + "max_ms": 0.03449099883437157, + "median_ms": 0.020289999432861805, + "min_ms": 0.01886799931526184, + "p95_ms": 0.023720849771052606 + }, + "overhead_ratio": 0.6604238752558326, + "tokens": 128 + }, + { + "deterministic": { + "max_ms": 0.026158999651670456, + "median_ms": 0.014902000315487385, + "min_ms": 0.010134999640285969, + "p95_ms": 0.021288349945098164 + }, + "deterministic_vs_native": { + "max_abs": 3.0517578125e-05, + "relative_l2": 0.005058898124843836 + }, + "direction": "backward", + "dtype": "bfloat16", + "intermediate": 12288, + "name": "swiglu_backward_m128", + "native": { + "max_ms": 0.10139100253582001, + "median_ms": 0.06691950187087059, + "min_ms": 0.060088999569416046, + "p95_ms": 0.0787468008697033 + }, + "overhead_ratio": 0.22268546386138122, + "tokens": 128 + } + ] + } +} \ No newline at end of file diff --git a/benchmarks/results/pr325_rocm_mi300x/single_gpu_overhead.png b/benchmarks/results/pr325_rocm_mi300x/single_gpu_overhead.png new file mode 100644 index 0000000000000000000000000000000000000000..de5b31713dd01ccf0593b85b9d31c19b581da18a GIT binary patch literal 213116 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�lIjgS;iZ=lUi9%NwhEgM<$CwEd8vcO`r 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�?kiC}B1U5b#SRlv$i1^8xp8+tFNv zEGgx-t6EyL-EQ0v#e@t;X)%h+80vwMoh~N+L9?vuU@cCf?ePfOBZ(!EL4}S&u<_x~ z1CTfjfCVQqp-Y0qsew3tm5D$eSZ49oFAgdXAj$Q0dh*b3HjG$aGSZ8AG$0x();HVQyT^|9hd*J#B95qXs_>tl9H&@2n%an#v-!0SR|vIcXH zF*lI|u`!U=KPSN!#{;^cN6W@X;!rU|Svyg489RhY+@ZqzqcbQdtG>E^z1pkWdli0F%8mj5dxv8J z?tlZGHXu9Xv}kPuMJSQ=A`@YfUmj3OmR-$$oiP!T5R>WR&FeZ8XbWd%|`O@!5w#d z@TwW=6jQ%|Q$)QTP~KB9T8G! z@zWgKAK4-668dOxuvh^aAd$d@ONhPjyJ)jTU^lL9+t?c;fYLAHNS=YHYub>!+FGv? zeO>U+@!&34I1ByF*kPJ@JotY`Mh30Agbqh)h@N%M4s5WZo`JICzNTUzNua2puvvcj zDgxD9;Tq7%jU(}`Y0kykamk`zsPxC^_oM|OJAIh7(Wf*pv1JWv^{Xos-k@zf)-mXK zcCLj9gCPF=qFnW(1V#%L67|Q2L$f9e!_x^E5g3?`hH@XzMs&om@gM&-l~J~@skoHN zEw?W2sm`L0%#ge-M($Aagoy*Y<#B##?GWE;a2=S4Lf8lFmT=IY?f9FiE;%T1u@o09 zy{NFcy0JI{BAWn~o#v^w7 zPk2@IdLZ}=F9qB26ObQ}^p8*$cUCK<48lg`=zp7Ia*`<>Rw04b)5hXGr4&hC z2PCp9m>4#1pzF$Sk1rbfg|;foq+K{-GhL^MFC_9XKEm0gEVkI}@#t!*3qfg4u$&33 zTW!Dq!KV#9n^K||NL%93hfW9U(Cs}%U-f*a-P~2dApnS)@X?7b9ku{5U6g(xs7ZdnOmf zdCu3Wt2P%-Ve{PvI5*aVRGLqCo~I7zCm`a&&>_g^R0oOkir{=}=gIB|@f?MG{2$^= zNinv$EDn}R_NQ&0^i*eI45Wp@wXSq27zQncIzBi7G^^?N-wTB)R~x+vY{$E(M_9VJ zRDV(+{tfn#c>SC%ua90ZfgyC(POUf)5v`D9JmvZ%_{X#`>G<(dxX^I4X*^Wzd^ndc zD}3j6d?(d%xNR!X%ncsJ$K4bEM4C)sR)LsVF@Og?^EH_+zE4+GZXc`}Q@nQ!6>?f7 zPPUb7CnI8~BUnxZj z>y48)%>revOoBwl6!=j?Lj%N1*PoO6x8mPzHV1V8_>Mr=r65ZHW&b|9 z1toIEZgF%7j^Iy0t)nU;2B3cGbr4&CGn$B7|Hog0r+l;uMkfBpA48E%g7EnU;!t3= zN7L~T#~(e>0t4U1)x#5{m~INV4w9O9e`l79Z}jevgt!}ns7k^vIscCK1uw215xJX_ zSlG;lR8%neqvxn1)7+VWB3Ugke!Ux=^QJ{0SVi5=FLOZyEh z?VDg`Xg>v_ZplUk@=$X&pkiu)sMi8Cb=|ZC4IYL7C%wlhtSJp^yb=T^@cI#Z=R(>` zzj9O@8T-XqP_QaFV~jt)0zLx{nW-!MaR@*O{EKOIrue1h-XJgqVJxP;!}U*d^)g6X z>D>*)KD{x!J#*?9@f(ahgf|b@8)1qz_!-VHo!d}M;(_EgrC)@4Ff}}5g{k<1cT({| zLXtt9^+AWhxX_50*t`KP{ADb|$=?W*xgi6ai2{e?EZH;K?T8qiV|FL?q4E$av@&#a z?*(o~JuZm8wSbst0|VTm{>zxwsibuYt35m;z7z?nsND9afJL)#gH%(JPFxGAEg<1t zkT0|Ii6qt)Y|FTX;-~do2kD1YhR09;N(dCDf3TxB9*yg&IR;^ucDfpqIIhtXvy!}Z z-n&S?yAF*65QJ^;%8jO28oANjq&BweQ_+dAUA64Jz2m!|j!ec+OJzP;=WP`jGy7%~ z$?58JiiD$#qDbZLkmb>uiGtt-ZV&+3Y!xC?@XzNP;tbCmKdz1EY?i_aQ~(riAOsZE zk>I5RE$Vr|j2AK$9zfbBA*$8{rO|P`U~2||(ID5Q4jg!k4x1HArz%8a)jp7xv6*Yc zZf6J&2@;UwaDN7}j(8+3GobPKijmoDs`!X<)mPR^bdG`S8z7TmiZ)m?+{QzeKEM~3B|M(-V z_&Q!K^f7&BiiHrl?KVL5Irxcz7@0EGSHD5xpMWL^yNH@e`n${S$A_DfEr}tXgwvsr z9t%im>ZsFVf7s`P4DL^;ZZn5jn&k>F@x>u+^1(_Z?55(35a zhEoiWZK?7%sZ4=Ksw*_d%Pnn?R8Y>tIEvW>MbS8co)V@Q4(i#ld#|r6OFCvyl-qTY6X~LGtA?fD2rCz zEzXaEg^)9aAR3ISjM6szF}X(qIxA^VO<134Ei|LE4PR`X-DigaV?xi^1aTHCN3R7*KkVwnptjg;P%jIg|J@bI;EDe;3aF&!Xv;$hs4#^CTVn z-aeW$h5Jp~2M&dnD|lAN=br1Uh`z<=DXX*i;OqwY#tfIDW-v`C@7*l|^gP|%N{PCF z`=8{rG{a`jO7TOPA#6%|rcgA&VQ-LTr^9NS717|`$w^5CG)Tdr4iq9KI9~kxG>_xR zfPZthA7;5g$r`djhmgcOeiJkwj4w&4`Wymg(-FShqu zXrr7)3=;o*ktJdn#3k|8>h82bt674sQ(-(_~VbrFtOvuYUoj~ z4Z%ceowfKYQ)XcI392Dz^uYO`xTIr0aB>|m_e=jG1){CFqyXL$=ku<=vnc{kvGkaS zIP|#Yv$)JE3)DubE`Q}B=iCi#-)FsoTEC~eGuAS(x8=Y5AifsOSp;GX?gn>lLTl+* zG|~qdwq%vnamFuN=))!SvDXFML5q00$^%yLg*}(fS+TpHQgAI`qoGokPJDMls}!Ue zT8{ExdTrPtK^7wIY{`tE*-AHw_#nFb7RNR9iXC9vN@3R5CX6DcXc6)aUBpY`3$&aQ zfJ5|Mhi(_Abh$a;mfa7cx}SuXy8eSu@aaeJ9f5x4WT>mxtEs7lZWlkoT=hi66=46( zPnQQxAY4lcT0PDuEdz1a43VFKGu+U(O!m%i?sXK+ms zOu(^k8y-JyhWGp=em7FSn1S#=r$7+8MypjzL@zz~=TjguG>=2nrH`TBWUx2~tUm_2 z(bb$DE1de&3>4OrdP;bN&sim2!T18i*p#2>qkzMOBGwEkd^&3@te4^+CI`Iw{8!pYP-p~%BH}zVu=uVWZ zJthn31I3PP$UtQfW;&8pJf~C+1g>@+G7}Z^ERPa&Mqrx6pPD-lJQV_M%w6IRiGz}+ z9d;*YRWfGrV()-VkVvzf%`vg4nVW=X4s~_dQJcb#52E&((*`&@j&*70o2xl}2Yo8K zOxFa0s+ebMnq&-6}C+rDQt?_o#kwKeD?W zbjjg>OD-R%20YMTBbCut2@N)LYu2-%p;{Uk7^r>b?k2i1Iv(01{;i=P<`WR=k!`xf#iEL~ZM#tAHrbs@MC^kT zzukbmF~f5GRTAA6X0lQ8G4!7J{!(m0`dD|~=Ijk&R#mCiGhq_7mlmZva98FI@YLoDCq zf0qCLPK^gmhL-QL7oO-fe9%K#ox6|{*oS_24On&IG&*yB)aVDVoVD;lu=VOIdm8q6 zuFt7rm!eYRp}yT0Wyxo+{#-pmH~8KEf=Zif+AjR6s6ex=JQ9izW&F0*zq`7V+1r`E zpQ}f``+1{#76mLJ@a2c8WYzb%Z(2e#ak?4DeKLLLhl)EDPVVs@D?Z$fRS>^TWk?4z z4CHezlY;`eWOC7U?#kKUU;fm7J5S`NLI2dXxV*oM+_8<`rx)fdMP4(astyj7w`tL-9kP-g$>(PH0Z3qCEaeG0G zUFCw9Q$IrC2|juB8$G1iVcE+T*}u*yKGAwIzeW63Qi`eyHWi{hXD{1@Igsx19GL|1 zW$w#Yz=WdoPk;Og<#U_dFa@;#s0F|E_QrWz3Q@zETY<=`mT~+ZmQ`rhfkpJkLHL56 zzZplIJ1TjXhFerUOSst}^Srg`Q}KGMI*_NVjxJj>;BQElksQk0K#3wOIVHU%CkWTh zGh>GwKScx;W*W2*g7ftr!j*$}BX6LfSw_?3Wsm+TzD4g@^ScTDh}46=Jd2{8PJ3`o zK3hBqsU4@Ea`qTt`SGYQmTXPbNPrC>9op&jSr3_b5%IF$nsLmJ12Og{&O!9`!9o2{ z($fnOP`5T(c&YW{e()5pY0^7pUd6Nhk4+knk_BQOrh<$0@6Gj7avYW6O`F?Mi>{ zkYw#uutt0bnkI-ioP@L=jhBnjo5JpQvWz6$@!Kv0Ja(!sL@g@}r-AzF5+Jb{R;iE< zm|PUsu&tK_Ej@MesM3YTUHWH}tP)0{3b-4%&;q_pIXYZQkrL~oE~P2)#{e9A60pXz zUnb~itzJfs^)&7SScM85?Qj1Tyns}TEISJM6N`@F*a2b(cmb>|Q8p}{Nm~6C*oFiK zA*jHp107lg_JjSh>@YSy3b4Z!&$ zmI(yTAMm%>2c^qcdeai*;~{~+SpiUwI=37xCtAD2DDpe@3~4q`YC3Oow1eH5*$P-o ztUa!s6A`G${g1y||IQ=;B<^74wjY>0aM2aD7ZNb+yL#*xrzeS$rw9ueg#|$9fzIQkF zU_Y3;B3fHyVL#b@<>2;f7llUIT~_7==s;{@LCO>bVYI&*f6q2M5< z9uc}-jJ1JL{-Rq%J~G^O`nCTY;=_>`2(*qVbxlHfFev;i@E9HS1_uN4#>XOe4zlOKO`=k&rI}zJDRzNT?u`$~_X7=B1=i{jqmlJS9AK+EfKSJn z;9MaUn&y>fC!9XKZ#KUWA(&XnFOoU-(c0l9Yp@I2n$g1?<3_S z74%0;!`bu!g0tCVn)rmc>jL0UCXC~t-5zCTbkpF)181g6iP|NOd%;0{@ZoOJ&QaIKTlPaa0 zMNGu0jfA`nm^RuK3mX-6qZTPs6v}yV2I6|#5+FvT(=vx7J@E~wyL_YxK%1L8=n|5( zcI(gv9a9GEx@z9n;*Z&y3SccxwJYc}LUQGk@SqGu3_Dq0y?W)X|6y|llrR9U<|Q|a zza?d@s*Qz%DxflG33jWvivP?o{o}$>;m@1?b(#1C>AttF!p_z>n6{}90xC-cM7&)r zZ;4<-)X-q-CGS39$qqjF5`{!E=e#CMl)>xS)U92O$VS2~bIoWzCe0!nYe>OKU!;8DqNY5?S zglI$Y1R_aU&uCAx1WPEO?rc(^_SfWK7h!J+6Q&SJ;;w1{>8qCKgyb*|L>!C+zG`N2BYfZw9W#R`B$vgH(LhE_#z|#V*qt`FO3pf^G++uYz4s>(=1f}(QHAg^T|>q(NZYh zrm%=mIwh3Es)!S$qj4|+7IP-k6*3fk*1VX4ghIbAE=;=+;m!HOwZWyk4r&mBQe593 ztxn(sz}1tIk~jtAuT~$ee~|FkqeFM(U&uLK-jqjCnh774q3qbayi)uo?4=adEP`o$ zK`PoC=wc?gP?ERAwB(tVk3u?CbsS$xJ!%=J6alUlOa}k&A1oFAe6SdfQGlbt_J8?c zQBBiJ=&v3u$^_(T=HQ6_>cMX8@zrhsFa#O@;=@938OJ#@O0c!J&g*~swUF_u(Faz4UX@W3b{MmqfP6(q{1^N6`K1=any@*?~1?e~@F zjRxyc_Xt)%<3p(|pj|qrO4x41DQlaqh(4y2mM#d7dC!35JrLwSx@QQF-_;EQMyYb}bce2?1U&m&4A?mS;of6{wF<~@ zJ@HObgFMm+B5>v(NdE7D_BuYuhKF2+^9=E|8B)PX5CIBPnFNp~r!nv<>Zl8R7y0Br zUuggQWct~w-8+i^fR|GI-$wZVeY2i@-0#=)77UrTO>g>wxM?M$yn37cH0{am-3!KD zwqMw9{jWdH_+ri+<6XzU-ZW;UZgD`+^QVEiu3Lu`e|D$EFIpqLicml=e;hGpE78iRDG%GKJ0K68HPR z333Ry^CqC9&t-8NOz&W9mvY}$eC^NO`L;m%u%yB)&X);A<}rqos36!26hYZhT-N0F zOB&TBf?fksP{64HkJ34RM@Dh4M#e1Bttka$;bmXPoLNf;2O%4V8;tx`9qleVKxc4* z7L~9KY6=fTxf1W758Y=3lX}$d9S^4)6>^$sdV0E~fK(v|VeRoeAawQNj&SyCbHYk; zR;Bp&<3Z608Cg}%eOSX5LmSTq(7x5}&__FVG~z|Fi-W1d(L)L+cfd5fOon%4(Hdbl*NOP<`jjdLxbOr5PVo19UV)KiPzHCN%LU{J5oz)7A-C?%h}r6 z8W5(T6qb{Yrxxuz>*ww4D}D*tue?^(9y)bu3^w@DXCC4kdEU)5`CON7gfpPKZjOjD z!XUe*&4W8!hh~bOU2tmL@5QmCCNv#SJ=D;Va~2HvOZ%-_;#~1=a^fi6#E#REnhvt^ za>ttiqTdxFAcX4}`_$phglAY!Tt-+2U^X-!w5fR}IbR{Vz#ks~) zT|#(#wDE#PF{3sBH*`dFLr^aD{WAe5}mO?XUz#jYv zUn&MUM`4%i%zcfmQUDnJO1gWI%^#!1-gph0hh$wrdMHUF9|}ZYB({Qm2m;qWp|6lmwWKG6(MmLH+3O@egrCPS z$`mz#kAH>(Y5%Hn>0-3-;_IW@bASsAF_bofm};1Oc3=CpbpVhU+94(M%DSo|{|W*E zzcFI0>aJPk?*7)w7{|4X3T~ml2dI}jqF55FqTkcd4a@GBHp3X`ut`{77WqD@rvaIB z4h;%cn@K&z$6sr2?5Xq=7P$~hBtL1?f_)t(v3h}w$LY8p9`P9p4oG|U7(T21d5 zQuK6u<0DQ;NWkwg6C{qPZ7|)jQ`u-76c}Z5ui~4j>~jgq7rz19IJH3*4wZy;klJ>7 z2W>!WgV3Ffqe$XlFrc_LKaBVA07QQ=O^K+#DA_ko{&Sf&t`PH7>}y)aF8bqZm44bC zH=c^avHc#LzV4;_^;vI`LL$P2WW`(t`{ZxY#%7)gWe~c7jb;FvvGbbnX9%Fz57K_Y zh;1+yU(|-f~n*#&tBos|C;8x zpO6-KM;!u}F`UDtUtEB!XFT>r0iISQ&GJBP7h^C_6RN=pJqE5Y28npW@~Zd^-FxGX_P$d@m>nfbIHuVOtOyo)x- z9nKylP*47t^$d1qc(}R2NUXWHsW)_&TuWoax4hD`_4T^d9^nnkK5=m^YOhaynRBqa z*I2#Wqlp`*4ythTQql`nGwzvo)Qb=AYw2F|7@OO(?y3~8_b-a*99LmnlBw?X^_(7h zd+<}S-R*7kavN&6I_YO@^ST8I2uFG10doxJY}o8%H`QaX!VV5=q-qG*tM!mi)SK(& zF2gsX{UPv~Pf_;iC!WfjlYmOI^XkT3W!Sfz3^*^LQOWDantRFTx>=7Ct}C{?Mc2eG z6~c=(34itJn<^{e-*MTwLGwZTCBJOs2odaDsSHBp&YaFCY)=L%e5Q4fW-9h32bUZ@ z*T157>a4`XXTzR%Tj#Gm_fgRIJu8-Y1>4N&y44`Dph8J_4z4zpxeb)iNoCAQe9aQI z-#?!niCytCc!L95eEi03)Uhb{JNLhOJO}Yh-(6N6GE8`N3pAMg%}EwareszL)U+Jh78}Fc#q~IyX1&NcGHc)K ztRk)UJLxgvwVhakh0p|d%)^LSF73^)9$%H`T{pE&KvT=%Q>z}yHQ*`Go>ioJ#|akt zEc|RPDTY4VHhtYWEyy_GJG3CWw!R?_RT^&Zv1E{{(#L?UfPJTUC9 zww)dz`o*zlt-XyCki8kmJCp}uo&hU_pz|BxxN#q)fc>&8fEKFqxd^Bo=#D7bIsL0W zEaXs2n}h1$uRsDYR66$dsw>X^*WEROhKjyj$@ZX^N+PE*RK7Z5w-+J%0ajQsb%(Ui z0B&p!2M^lPcyb~;Y%+Jk%-(LbuJ{FJ&-p|><^@bVtsgbxs3`$dxu0=rfR`AJH!iVt zye$T6m16xrn0ILU!GxLKAAl886{cVWt1C|Ci~axi$BDEEPd;&jR?PUEv-_TxtY2X4 zclz!CUGEm(|0srBE`6rJcUWQkoN^R0qCl5xb}62&jnV(2ITr5~5xZdms2`z>@& z1=MylEXy1Bcx#u++nbgbr`#?}LVVDgZ)D+n{aqWRUUYwJ@#Q3b_zwU5G2o{X`#T!0 z+~7B^W?##1!41oP8MmP7S-th@FZl)8JO0HN{kL8W|8wzwE|ULdyZC=z-2c2dNKgNJ z9XHa#bua+rVQ_Im_+OSNlDYuvfrft_y zv&fY6fQ=tykh1bWQ`z?qF=OBVvDDf)<0#0TXF+YRExRgNtmlZa%A+f+4q`&%UZ*L3 zbGj;3FDrT`AEc5U9eMlNSL3@VmG)2ymJkW|8`mY+%fiyKX>e+md53>f$HSXN%fGt% ziA8&a^^JX9m6GjI^S=1qa_!o+#7W#9%?c^EY`eaEv%9yegV)`g?k0ZE*Jk|EaAd_u zuk|P03S^M-4UgIIhKu3+E$@JHiCu!153ZMMnoUa6d==dO!}F&egO#f1m3Ga!O&kji z+(W2Ypz4J4>8=C$tNiV>am{HXC}8MNM&n_1b#*FR>QINyTh`w;h{j2{BDRsEuD4z7 zo7f$o?M%?fRPv$lJPZy4SXS~gk1p~M#?HGp53M+O_s81PQEIWSa9W`SG4VgmdFRK| zKAqZST1n0dsdTPsF#`C&nO5*?&9St#jf~WCdO)%tRBKZAY!k9_5O=eSn(#Yt+1=n( zhOOMZ($Drd9sDtZZ zk2yJQH^526dr5hLvP#Ai+?v;R2MzB#0kD0?!4DYtK;^pEvi=%3)9c$Qwqy?nRdL(& zsxCo1xtH`b`o=16nI0`l?|S3R*pAm6m;*d10_Ybf+CJ+QVAd11z-S08R`X8T2^Vn* zF8Ru*kDT0Kl2414W;poWCwRnu5-{uJ=niNd|6RGgjn44+lA;U0pZ>n4<-(d5wH2u@ zETMX1LPV zgMu)p2N|q($df+;N9Q+gXN22z-;H4Q^a(%Hv<>i3qJ39LUr)cyJ^dR+^z76pwEFB7 zr=QB(bL5YmUpU>J9rVWPD^RIeR*SQ)_JUH8dR~KXx&)|D8qCH}K{rb=GN|@*0tkw= z>1X<;?-?vJU!cwpfW(Z*u7U*X<?_Vms$yz z(QhN(Bq!&+9*q4$9spyAhLhK%p4;}AV;yL_5?UDWHE48XyMXbcsVI9kLK~Mtoh%XZ7&300y$TRA`xXY7W_fCZ1HszK+3R?z(E3^@yNPH-fcBWQ*8LVU z>TVuPi!LfEYNqcC9@T1+LXy%hIaF*2e-wpFEANRy?ft{ zduJPWvlseJmz=shjb4~C%}KvF`@dXb8$__qF~chYjk9`N)mk$Ro}Rjbi1>3n+8)S% zVF2SX20=b@Jmy^xEEneg=JkxD{m|;Pmks&2WdLPMn}A6QqGxm>?13a?82;m{=kxVm z(=LQ8Hs0)<&%PTb^UWb^m93hR)Svu#RPXR$5O*aun!H&;%t*?5mUBuqVZ z2%>_qjlyzq#}gvOe+5`B2O>IPyN1PBbxr38?povO|Lk=w7w0z5yo;)1buwt%X z*XN`ppr}vj3$}!Da0X4cKzovV4uDgQG_t#G84T9EmW|Xfn{V_S$aS5kQM&`kR?;S% zAXLJZP&B+?%Jw+Mb#hTUtLNU`@A_&^;%1O6b*Vvby=k}}@Oq~^;++rHnTmGmkIFaY zFt8|~-8XjfxocgLVi8wK!26=fto3&4VdeG~M8Z1Q%@$$4ofXhia^LTo+N1rd3W$JW zw;tK+R8*MuWX5$WC^)#5!)h6rc(Rf{kv2VcksHt+1_z$y5%WPUpV@s`RGM}UJ(eEm ztAbo=ZaU6GH#CEd4X-*~41vua`lzr2hg1}MF~MWb_%<=!z{!8buW0xg$ECwT2Sc`x z|CaqmbXugx${P7YJ|Vwxdm8N|~wd}RZl=RQj}wfM5U_Fb%JaaRyEMznP3cMyQK^L?9R-834*8Ja!C#r z7pIwp4Jxh3J$*3;;zlkQ2jKcXC3;ucI@<=z47PHkOGBRytD`+j2X=|5w3zSm9D%Ej z4I0=D!kAeaG=dFi!XBuHIHL?xO@v9MOK((k-BMWrTaca9{8RseGnzc9z}{jJ>8`k& z%QJzzL@9>0>!s}-Ik0gHh(0Q7>*12%IpE%Nm=qoyAc$LvJ4pWiOcsP=5>T2O9& zgu`0)j$OJJBvc*D5a#lDVot>-E1#R^J$ zi;eej2ALw;5o|rM-ZI<07F>TCL{%_-SJ2)|D@CCf6H+^>-2|5-9ETK%q`S z{pY>y^ZFi$oI)ON654*#JeiUR67=xy4=*pbeEX@bRY8*?Xw8PtL} zlH+LNdb#2a?K>``5f`QK21#V zz!|)A$n?Wd>PTg5r@;V%Su6KI#Wcxt|H^4J6`|HlA2XFWb=}Kr)N>ouCmOfWLC}1} z=q=`HfdQvm=UOyi3U3)s|M`!u-LkNs6cHIIBz%~_wO4}BEky=mpR#fD=LR!+2ADx6 zlC@^k%7UR$-0Cc5P;>03$s1-_mLj2J62R$bbW31NV!t8WNH%WSk>NbwWd%M6Sx8tR zBq8%sHX=oF=ShmPf*S_jT$AWkht%~XwP_GK6!}>n_TLNBL#_acnfG0u@7Y(;xJnBS z8qKqJxqiCQn>p;8o;#~AZ#ND+wW%BzFLmAwq5gMIPsdkdve*JC{iQoQ!STZPu$A z?C9flmpK_+kPb98HSw^c0gFHOF1s&L>e3OJ9#B*rUP1(nrp@-gCFxtYY|pT-IoQl> zS+E20#U{HCKdZvYJqGPUP1WF;w?JToddg#_AqEr$>gv{Bv*7m2(O5hjds^uqlas zPBL1$WMR}XRd<{-&Ia*vm}@jF8C@Nl_c{kNmN|l$fwv7Ou;UYFVXzaPAv~t`ha&~N zj|WvkbC7jEBDz2Mbvd>M2XtSDR?8P5x^HR^$IK;rD4k&Aj}?egNq<1SerX+ zd$){g9#PEZ=+#4Cngum%` z5JVmrPOWA$8Pk>+d50&5Qt_~72h$6K%gZ;sV!j%p((ggFymPfIq3myzLhzK~G&^)4 z3NwAsIx)K<*NbD)=>N78N|xH@Ls&KozB_@_45F(I&k)-=K!T^|`xN*VdeLb)$L>O} zc`Dh*fvKR3K67SpD+1LXtdzcGZ;`L_z^DHPjQoW}1@BAMs2XkZPmpe~&M!G*r=t4$ z5mMa}W=ImY4pD#+;D3#(n6zI%=XkUxMA15Q16(3s3@Y8)_i@|dKF1#`2b#@B{{jt~ z@;$de0mxzPbX*haA)F=@BMkDt_RHEX6)V>HA>`lzMM3&KhSp~E?S(u^gV=+hyTR-Q zo`18-&h9-20T5#c+rYT;&`GtI15a?~Ev0^lV_az5+gmTqU_GW6=%O`TDDo&53xT8d^DMyb<+|g5fUlrP=Xt`?71eY?cUxT+fl!Es z3v(1;f+y2lZTJTQ8Wnm74b{4s)xzH`Wu4-NXIX$_Bnr>=YU22eYcw}UyDG~h&UOjc zoHTgEKoxFr{8lO(5fsb`{7B4FHBgm27H0H8ANT|xeHcV)0!eK!?h)Fc> zmeqkijyM{&v~Ej%0Ei&tGqo`zda8}N#BLUxK^}O8Tta+Zh)5aNChw`dLVIo)q)Bkb z>2$vqh05$bP)N`RTQD4tWfI_|VhD93IU*OUl;MH0@k^R&8MlbK(Cmy=3>%XW_+w)^ zRR`iL`sTu)O^YLrWbyy7eA8AIbYL*d#J@7WYFV^>$9m-Hhml4whlWJT;(X_0BrH6o z=#hvI&ErHZKn2-n_mz%|U12^R!SNOn7lwR74G6M{X9g!Ci6dGBm$(N=CCYF~a{{6( zr$f+#{jdvnp(~{up62SMyCoJ% z$(8feHfMh}0i1^&I_+X#oaFPO+aKG8(B_(Q+~%&gI<&d6p=M1u z#U2pw09L{i`~if-G#1;9Imqg4mS(yD%LgMC`*;q|6HX>QjJI#+JH-I>nG{Pha?*c> z8h!y2M3kp6n(6FJG!gzs$d9jB^sXb2|Fzhv4PR zDvH!1^g_8EbTSn9G1=h^L28DNuAS9-mUoLi*{`fwmT+Jvwv}fMrcz*hB%}JS9c}6@0=|6ZLIzSG%3@Sc5 z^XY5sM>nA4w3`Sm`&s2;b6#!;aSYfRY!@CdtjiEgd({76@vFW@58I=#6m$FSpI;C6fpbkn^!brnuy;`O?VSpzTK%R zqz4!ELoT;7A+4W8H0D;=y^~pk^39@x9OdAeS@0R3LV~8}*ErGoheaxA)bAw9(PnKuO;a#fvXM40i#H+k&4c^I62mY5=4hj9!%fEny8pm(x9-gn_m zUIwu@g`FrMhEO@liPRF>U-=>dbVvBDtlDstI$fN~rno^XG(Ozw)n|J*23U@8M4C?@ zP-ZDK?U0!Ls>N|c%$XaUyJa87CSs=2fBXtpD!)++Ge6b`w!-d(Yx6R9>6d;7IavmI)=LA;fvCQon_tZXrapBOkYbdIP9~Mh8~g( z7dnsdq#j_!&!l<|bvO?j##XA&>ClUyV-#9sb&dnp*&xaFLfjl3w1l$gs6|Y0F$e=1 z#NNVXagX=zXN7ar_Rc1d#lOYege+(YdtELm_GIBnTz0}VWp$t%zeOUyi-FTi8O z2e7QrXbSI;7~=Klf1+ssZAu&FevzGtzHx3g_Fe4P_myeB)#~@`OI441hAhDFMVvJw zOnic;#&?`ahdQYl4eR=NwJsUQy1L9pBt>gpGtk5%xGceDK{H23XW&hG!V$rg$^dq0 zwM+_myoE~_WpQ%cqk!*~1C^?=W|$_ht#su+9j6{4^#vhnYp^V$+7Gxlsvw>DL;stK zzn2zojPL@((0|M#3pQF2A7Mg8(Yf%vc%mb=-$xl)!ocSYCqU398h0#Om;4>H)`F~^ zy%PuVEpqC~ti5BTWd|l^&KxfAyUo}VQU|#~s1?j|9DNB|61%(Xg z7Sf|z$d*zmx|yR$mvGGr6at=H8Os(vr9rX#2Wve3RlwCM-}8UMK)51WoO$Z+Oi z5^rrlY~MFH56QtSIC2GHOBj(zOGUKe(y4)c4gy?-gH0n~xAnDWUyZ3W=RuBYjT{^9 z$_=H@Y>ZvJ0`i4tHEsO}EHdHN2f}9e4_lO$z&$D^Ygt{Zo{c6999j9k7XZ&NWZ~dL zC2rT0+qIWOO7mjQvJ=iA7+0#(<^Ysn6h*Q$pu(Y39Sn6V={C*K4lNEDVDu4=| z!5doV<5@+yE#Cctcs~D`_s2o%D1di@)a*Nb&f(WgGI$no(j8AZ0Mt(Bf1iK=<_jd< z9bRsQygrga1dB+d*7{AY**_onzTh@aZ)OCv$}H24C}Qx)^xnC9r(g&`{z5Q`jR(+x zpes20pm~6Cn*H-gZ1&-m^f?_=v;R3^Sk@LGJ<|;Awx-TUeQt(^q-G=}b^Jrfti!rw zVvL-YFcwF(z28u?9^ZG+jUM$-{68E65Y>{A?r!2L281J(QQzD{gJ2^Epm<<0vJ2f8 z*88e4-$X`6dTdlQ<$3WEIYk37&AcrgZt00LX;_&*+bs^)#lmI+y(vH>cS^YirX z!z(%hW#X}atcrV};oP-v_hAIYR~nylSAElm*2~h!J1+CiteF4ej&aSNUzmh(5&}r0 z(xZzEpAY>v>)?o^90|y|F!-Wc>6G+S&5t;BkPYyxu#jZ?AU7fZUCQi#;1>s1$e6M4 zuq0qGX-T3xt&`XT#_1~bo2z|{4K5&t15xF*JzJf#59c(`FuDkZ-OM_5>eQMc1lY>} zfgQk$wCPzf1&0nnjc^GM1lEr9!KF7iZBgW4STl0KH-31!Y%)Y47)^#6NuIs?()xY0Qba&DHo&UaMJ@hW z|Ird!cMABN+4Nr^I@6;lNJKmc>rNW z1JJt@7v3-_ktISL`ERG-#HEoh30+o|R5jp?$Za#$I<=xEkJ%l-h>_d>IS;53#$yd* z3*>f#2AE%P&aZCi_#yal*OkM5&r3%HWZMo^1bsYj#=S-`lG4GD&4<_%()5?(?jZML z$C1#tN~1@qkW}C*HA>I!>u~AW=k+&?fGc-ddu8Wk1>VeD8m<}b{sL)yF+R$+C3?E% zz;Ht*IkMl!l-_gX6lkfq9mAox+F0wPvHd*BG^&OpaEnS|4eaX1`Zsg)QyrAInCD^HGJ(CKMoZ5>Y|5>&-3f7xM? z)uMd0E4lRC1zJMAfz+M{X;@eLlo@ETJxMeW&HCe8=gfCao>ISyRV+zBTj{yB2giUj zEXEBuYlde*d8rf!Hp#eVcm2asWb=qECVS}A$y z+}3pzWv~<@MTGnN_p59856n(z5JI*8Z#9s9)Q4=662 zQJE9|92MN;5Ry9ucM|TFRsTuI!r!UA0JQoIitpuMp3cggO2$3Kx;Ddiakz*?u0KLL zUtWzYzHQXM2(nQMG#?8ny{c^1TB3vgKF!t?9J5P5198*MD zCa^!T3E3g*ed1fbd7loy4_;(3(Li?oA>U%7J}?{roj0xTslD(6s5zgI2C+z3EsQ~0 zY6n9V=ksafaRmgn7i{Y@&Egn&gX?bLtjwNVJFy3~A*2R2CEmYYT}ek)0O3r)nGVuV zGk?o=so?& z9Ae~z#IFN!wtJ!WeAYG0Hub@;eSqIo0)`flYRnjT>5X4l&bkw5s3A}X`4`3`i__o* za-JDJ&dV3-%Z+SKg8&djT%1OMJgkmH4Nj9e=jUBR;vaS~)P4G8^T;Y=NC8pb{Kbb^(9)!xpcngEh|X(8+7O zw&+#a524(HF$);E_SIj`fO8_|#Q@52Ak4z<;MvwH4d*stX)h@t_l2u<2cun#=j{}o z{9Dlc>u=ZMZ09==+O&vWA__60A|RBou!wp4#52E4^|dNqpr5&6+x?D4dFOJb`;?IJ z1^FHO+$IfOw{8HfE(Le#>O%zxjFAeM*?~Fmz)?g~Szo~XL!~dyr&;u1JE;ICM;lb) zbgDwRy#!-mucI^$Ykys)4j7TyJCZqG3Zj51*vH6owwTVL5&F$lWIf(C$FYkMSqEY- zpuhYQNb!?-UA8KxW&m}>yXy~~k*v=1S{uYZGAgCe>05@JHoNfZ=A*1?8C^+c;$4?= z&<@5?c_P!~>gKcKK@X;K9nd|i&(!VUSV64@fPGyULz3(Sm+ZJ~$3(B6k^2huAyZB$ zmc}vmkbth$d_t^@yw-hr-qw)*Uo!MjDa3Gy6>b-uJXsa1Zahd>U{6<7Lhc3BbTopJ z5}rJL0Qr-+zyr|Z)pN`=N|w-*8hyJPww-S;t(Zx&0`1u^s$-%@r6MC`-Xt8+wCN|v zO2!H4VG&+l1VXnKr=QA%Rfe&7s3G?d)S@5}H9n^h39aeK@=qdX^5nwgFRaOMkLgcp zpB3STZdlf)y*JOTvIGIY_H&$A6HzuW5hnR9xemmaidoh6Et>5&wJWC9T*!N(9&=39 zD;sp{2wI+Ej=w?SAeOOI%>Hl8qY8`X> z=?%EvQL6-Kf_NYP)oEaEEwa5Cz@3>iEEueNv1{VIPtS#57u;IA~1 z;aK1foclsSj0BG2iI&);NcEpqt;Mh%Po#*2G`Gd3mPlV$2g!-2YB^=jOb^(mdDGz- zO=U3B8C+dpzup-Zh*8|7w3Q%!0prK41wAQpA*{_tXt%bolDvF3(5~gUB@*g@H<8l1 z6Bk5+DY&trwhzDWJNR?1DJpqLOAzlQV{_tjTF9d04I zqvkY&*U;ftzNpqP=*y0A96YmFuGUcs%Dq6!gJBJ^mP2i{*0$9}T|oq?^SHZ0GjR|U zPlWFlB)XdP+DpTgCjmaFHS35<(o+Mc8iy5?PDB8+z!g zvG9LlO~9Fn_vM-1^Z)HOu-Gw6u6>6?y!FrfX*Qw{5 zOqqm9MwVuqJpBXN0?7W3*@WdK4mE3?YcjBWhB_Fi`QTlwZ0`ldrQly0Z{MS|hgTG- z7u4HyDd0TX`(RKmu}RU!`&pP(>K<}qH}>DCv`mN&Y;Uf!&_m>;yOKcJ z^K8^eJukzniw9o8wsUsI*XllSPaUK@(!1g$EA-l$w#8 z#foUSnp#h)iSbLNG9>Zipw2k3aI%*5nU1yqRxny`VEjw@w`Tc$N`(?GG{>i zth-MZ4BK~~ilW|EyIXvTrdf^3e$nGKZ?>i2iRA)I}Op`3uiM;}^%w?xekHXVporUpzBe39V1ksgtcKUZWIGBIQ71iM-zr3I0M#fp{j&1qbE9 zRSg>y4dxbz0in8*fK2~sP&(kEJP-ih-ddcUG^h$psI55v3 z$-8i^?fyxVNV6W$?ve=+7dDOdIlzxbih`@WX7uERxV}}I ziSF4An}30#!VOE(ly1c+vToslQhrMA6-f7Rhc|au@~6%1i~1P!9tht)VMrTZ4r)s> z%w=TAa2lqLcdAXlnelu_I#?QP7O*IOhT|$`l-Q2{d<^6)Ihdv6!xS8g!U0=`RHblt zI2s`yPQUebV_xS5U}=mnh=p3GoXu1XLYaw@pG&VbcME9-&21o&u8a+b0EU}_oRLg( zkXGQKZDV~VCYmVUJesyNX9m`CIgST1_Q;lJqneMp*~#LahNm|>Gpy$uhcjiN0)U>E zP%d!9R{`xrsC~wkD~kTUZ|P8qRH>f8eag#sMkZwe*JH%yp~D27i~*YuW+1u>LMZ&Z z&Q}`BD9x(ZV4uTr=yW-jgo+1oN0D^J;R#S?h za?WG?CmQ>4A|LBx7Axd~Ud&rib1PSW@>8payPfe%pPK<-1yXFE2 zmvM}FFAOi!7Z2x`K|y)_w5^8!W?|K;`bnkN^#RJP^?@tNuwXs#`h?aAz@XSS5CPz{ zzWC{HUW=})C8DAuvd4Ug8X}VAwV&3JY6rNIywNdb#TWJuXP!Z;%up#oGf4pmuYIT& z4~~~DOMm$ZMuptD#4(f-8Y5YLrgf&kxxJ59>>o*MQ1waES1DKF6_NPm5b&@=(L>F2 zrVcmXZ+|{^B7<7&^2PEDrd5{(qpl~LV} zc^`cy?52hdG^3OQp(O>(%YhQ<_pMkFa(SlRnBM+aTa;N*yn#3-joiNB90EI4EflDd z2B`CjO-V`lhkYY<07|z(z506{lzXhN#21tQ70x}KoQYJvJi`N{4;i$5g$QZ$oVQn6 z9kgoVZ$;!3td_8wFmMOqO5lEDj5G%5S=C&di(;Q~nd^9EkRbqj$_L0C(l8C!X5X&L zA=Ph4WdPT3V;+SCmh5ZO`eO>DH&UFBk5L%?_b(bz^ti{FdBs~@{69+tJyIH{ z52X@;)PnN2xkMD87k|L{k_+0eP7Cq=-R)6|fnXVgX-VhhM#w06DV!IE;$D8pgG1%H zv8Y3Dy4|?pw1Mr$<;FF{YSxifCCnr-d%O@>np8&IDhFK>VHbazGU#PvwGlfipmDX@ zpL8W~Q{~n4i`%h3b%4$lRl`OP$?vsb+v?s$hJz{9u!1a@46T&p+`B`muap0SicO4m z6eA$=_yCyjV8mgJ!+A^JFs1_()!?D`n_gtsHREc!?l3KHu5Lgz&FI#t2M<>OC}t<% zqR~|Tu*f1HUr>H`9TN2l*dhL`&~>ZhsV>g#A{o z`2Lq4Zq#Av6rI8R1MsnQuE8keO1tdiIxmOphUN)p8|km%QW{;=D)seJ^6H*5HFlc4 z|FCV8T2aVE087F{p0nBN4liHy+NK@uh;7Rfu+clEnlq_A$C8mc>oAbr%M3dPzJ^MM_RUtCC^okIq_I0?akry6xsr}ED@BnUa@1HGB>ZAOhppzNZ=Pi z0&px=Z98%=>W2B8IOlx${uNVR_|=DC(YACAPZ+d=NGUs<#%Eo2DW7)mll+_l>Si)hh+Q6=Sdk;Yg*cv zb3z+a0%trPl(l-lq+k79gFZt%a1kxbfOit!@h z5byb;LuZ#W5a;~K+lZng;jKe!(M-WES6VT7=_rP^y?PoDYEaD|+OpMf{X`wmE}t)0 z1$dCnEp3>(8;K|MfTTZ9N<81O1?9gifz0x3Yg~Pg5H&JgVbOEiA;vdOcJwm2`KG!1 z`TvWrGl9x^{rdi0QAre{j18hBL*|rJ3YkhWrzm7Ph71*HA}UknGF48c9J6DHkU5gf zWN4sdE)hlYes=!Pde*z1_kGqn*8hJx?(X}(e%H14cYnX%y{`_Y4>IIBSb<^Wj@rOX zq%>ANlJe1}mvDh+U?@Ah^ZCk`K+1ay;+svlJEuk5 z3#~=?X@oixADG;mQ|n3O(}^0!Ait5)<0bbqiwCFi&(IzFj~w*Gq#&tNX5vPbex&@V zk}CpQt$p+5(`TLAy3l)<ZZZ89;Kq?l8>KBo6eP=cDL9@6D0(_M6(762S#e;h=i;IruozZS z$cfQawu+PW9QR3q;~VJYU6Ao|;8?j{SFXpxlk_h6(yYWIyX*g6#?OmH8J6z{L$;4p zeD&_A5_~a}mgKerBjs;;qI;mT%|sQsH9_v(Wsa>W^uaKwJ^`Ad4Uz3{ND0mYK0F`a zOlnoRs6-}l#?m;sDQS1T^9Za(y)RS^XK?wCqah95&sy@~`nQ2o+!dpX2XQ6n>%zDYJPTOvu|Arey zRL8L@Js%t^`5_k@iuf%ok?e}2s$yXg&9`H9H7dzM=5tA*Gv0e$Pw_Y)3l%{>J5m43 zwT?1JRN&(x>y+a2@6Lr@O8d>mchhYD0)9k10uM806&!zDr=x31C^57+#(O;uk}KQna>BzrF<05z>yq z71Gi@H7mYZ2lrRmQbr{Y&muzJBkqcqQG}08T^hFR1g;{y)?RE2a4o{1;JG!sq@~1U zx-NvN<*+C5Wo82WB(fJ}m9}j9qmg*z1-8Ji&g<{8CUEPojAJF0f`LhjC!ep4a=J$` zS}V43+{aXyxj1@G>wn~cupjctDXiSmlLv3&IZc4o3mZ+=R>ue zfJsNJ&*EEzQg_}o2Vzw&&2evarF_l#5}HPDNF58LqON!zX<; znyvdvV}6#<_~a%AkY1N-@I=IRDksp1j@YK#L!+!!YH|$&fo zwtqsQ+(g6@c}LjTT-^uC(hj!Z!DfJ7(?MM!3+1-q9nzrY*`ixVgt(D|T5pw41%@Ge z_f2?cB$us-D)Jxh4LNUp3=B#!84}~qp?Jsfu7>xJfvVot4`IHYL#$w;YG+Nfw5>0;((kfBuId00% zJn&H(Mg1DPtM;ws`vX8nkLde05i#65{NgL={*Z{vqdM~Zy)gQ6@mg&+APT*-cgaTv z>}GvbIsfM3U5Ss?Lnh0h0^1B4ss=FJ4wopJgH=q#wasu~CPnq&rTlIGE$ZsbdR3kO@ zgZ41KL&o%r(}=kTTSbLnjV%j8RHBaixO_2h+0EwF+V0}w6rPyw*-V0-pjt^Ckk$(! zD!(P=`-wcpnRe#*i#r-V-U_4i#JaQXN9(NrC}oV)cH&*HnsaKUL;$=5H5;1y;alt; zTvIK^o7!ObuJ=lIeaX(OVKy`JYny&F7>|6JbFt`@*4)Io%+i zmy2spIDCr(Tg-P)0v~<5i4|(MLxTs+!hfETV@>HH)W2>{eJfm5aM2wlBy9@(WIj=< z+gcAB?4R6_y?F4UY1_{2^AoEUJd~Kk?vw2V%L6L1V3Wu0nl#fav}{^etsn*aHrxc8Oj_5>1nBDL}iS-d>que zm%)M8eS-6aTaoQ4g$DeA*!>tL(y^yYec||XM0$|=N~8yFme4N}iBoi2>bE4QO(BUy zs4hNP<#XyImLTz3%NSP?8wtSM0Dof}*fua`ZiJ59`7JgM(F?_M%ub2geX|$HGUwx# z(=+bw6{BjE-2Wu-i-kGeBw|AH{LlqhU`u2cCRPoZVdIZ_JVcA zQMjgeg7wt>x%8U_7YmUrEf!Ma=Ksw5F0(PjjCw;_zCfKt{JWsHZ9kt!1?9_dg9Xh_ z;5>T`2sojia#7>iYj#<-Tm^&LSN-kO1)2D;MPh(-qaYm%VJ;S!-xiy1N1gmAlC}6S zoP4RsN>FFUO?!X&@psI)MPkN%4NH&5jn$W5$$g%a!Z3jb9!fTNxB7qpJ z#eWK<8Nmr1`*Fy~X?S+!u!_e8HK&8XHgVm_ulg@9rg7YFgDU#qv&2Hn>q~^7(Cs`l zdsK=vyVlmaKpoe>dB}%3ltwYN6r26)sM}R)l#fyvNDnG5qdgqX_HtH^{KEC{QToJd zo7zO5lR*k%Xke9m#8^a>-28h#m zNPA3MHmbjL&Pl`*a3vN!KyNK~4y9d|lrLtg65R`xj*XvPI5}>~wil8ZgrlM^kyguT zw5rEi`OO7V?Uu3OAk`aem>>GPqc7MiN z*r`by`v0$~Tbi#K)BQWG?ev`8R=wpC7lM<=uI0td>YpNwgRM-n1Eyr3`e0EbJ`Aj5 zGNVFT-O%tluG$2My{yjTZps$$f#QO5`cz)QWIXA<7R_h0r*`arhZKZB8z9z6hDsgJBtXg@3244>T z&pvVhFFd?t`%nZQ;edozy*f?UbQ(WP#*-4hNFyFqhSMf07h^z#$EM;9hKOOJjf)j< zDn7emm|DkHEmiVd7ot(NuEQ>E8!}aGOA6GvKw=n+PV1u|aqw%=K4EW-R+Ij-We^a% ze9fq3XH#94>CBo;i_X=%r4npp_1Hd6+eRD@kl6t8E({_WQ`t`_7imwUWV8+jhr*F z@OuNUkPzvFk;yxY5ZQ;)tUu~k|8JkH4<)B-6;$q<)WLD&why`A&l#@$OFMk3=d~x- zx-Pk)cX`~v@yFH{Z(KY~GZ$OIleU-QQ;c)BZ<=voap{-Uk1ZFDT8p|-`YWfq^Y^@0 zyB?P=J6}@0?dUnXYqxGMNtw5n zB)Q*>I1u|_?8RfJPL(k4iDu16akc!|^WbgbKmTOmT^8DHn|GvMX8**JB@-sJ7%^gm zgM-7=AI~2=*aDbDtn#D7w57ophjurp6~>)eBsWv;^)0?>G_Xg+Qq92~i<*)+#YT+q ztB7jaaUc)s&C?Sdhwto_{jCp|y1AcSvW`}q$`Hw|l?JGlaTX>QGDu4W-s5XIPF#6rEU%%bdL<_#Y8OcDT+ayPSe!=I@ zpT|v{xOwBojnfu{J$W)NsQU9Disvh=#nBTdnid~6OsqR&*5gCM+@-pwbt_w{xW|99 z3@A6=YBt&nTjdtB(PsDOJzN;_?=x93u1_mhIDQ@x{XILj`)b(4JEs?TTlec%YmT(R`(>|?wr4H;pJ=BR)H->9&)!l4hV5rOfsHtn?1$G?7=m-F+1-^K)cpoz+lhMFW<=x zuEnq0X_R&_G!z1%QHvI4UEC6C@`3^EXspA5*9#UezIyrcilU;akob;-^O&wvl)=om z?gbZ>mO8Udt|&JPi(VbM&B{*OckTN14H;FIarv@J2+fn+-Zl{zc|=syr57)D-?`(0 zW_cMgi-ysqJ<72dG)pt=uM1(qT z=|~33@2KivKBIkVn^Qb+BO@b_qbfbP``B@nm6h`=-i=y6zS{4z`JGm-&DpD)h*Xnj&(4C!J$mfeOZJ8T(xtxTMNVuDM_#>t{rZ1r zKVHvoRr-Chk)EF3os^MntL7Q0_PD;UNa^j1kvnc3$W!XDr{0cNqrQZssLW{dw)v-$ zl0mk%3ZlYGN|?(T8Md8s@HMy`7-zA^I>6q`%Lou;+_h^oWf!WkjKE_pMkFsg$9E&a ztMGKeHAZ{X0=9hpVB=e)e*XOVapT5ip7k-)(cn4WdH8Uv?mte>&OV66AD*Xej)~FZ z1!22)w-&_s@A36%X_iQi1*q~*o<5B#&v}(-t*xh*$=9>6u$aQDwsf8};n45gr%%16 zPQAj8j9k06C?ixwthx6WJa`|*ZND>S&mNWHl3zHofwJwZXZe5ue-c=wMQwvGaQ4^3H$#^%rkn zH0iF%uo&A^*QCtMOj~DX=R>`(T)(a||MjirOFlh!;;=al9&FIL^Ll!@SC^H|r-jnQ zY|H`E{GUxbj@jb(NZb2nxefc(e!u`6@M-C5_H*0vuKTZEy>c2l^c7j?^qDi8VqzlB zpSK}Lu<>M-Nh3uz%5VK#YqU3ys$*E%_@G~yK~V~G4;KEeS>CF3Yj8(g_4mf@h8$V; zeXg~&b=lXiQ^}DlSFOT-=Yk12JT-OZ$)@U`8>a@?+uN&aX3SBTo`4H`_ta6$%e!uq8drgA<*^deH~ zp`+-pZ)It}(a15T?_#sEGZw_E`uv^7jT=*v)*X_xiM{rvym+XFZf6OCx?Mbsjg40# z(%%7JTB;HSi}Vx@nneq!g^ap()o$CiEd~*_f_zoGnaW-?Wy}Cy!Dg!^BqZ2A3RNpB zHPEp;{`^949F$1>!GqaAhtOcPt?%BySD8FziXHACqCvFZqh)b=+NG*HI+~ej@Stwp zx;5_H(w=lGDPV9{kz0=~EE&<+^ZYF`)#=6Wn-N=*@l})?7-zcI>1#_{q}2lt}k6DCYZ53JgRi(jSS<;$?h$Vh92Q{yI0RMI^@_F%UX zj&5{(zbZWZ^Vhedz=|ONfok*2x!)ZP=WSBm8?bDd%3;4zu5r7JUR=PiB)3@3$v?lF zAY*}IXx?OG((h&!ifrIZxP3waM7)B=h)uwosV(}n|K&%QkfP{&2%53aGV8k|w)B7V z{{5G-!U2qMaRNTbQJOfhWv5P^%+1Z;JVLkMDDpvdk*iZs->xy1@1+qYt>j21|JlSyK_(}Skv zCr_X5!v&BHGN2;Vs?TO5u_v21Zw|_65yFF%#0ON`Gcy=899^1xd zH|nv|EjHT2{QkXrilTC0leve72eEbsOo{~(=$J$9PE)5QMuY}B6e-&kg@v{4)M*{z z&*OaH4Z<%#G1^3T@H!|6ruvJNO;30L4XckX)E)LZ{XJp@<u9N*4*5p&(xuIm&4lw=EX?89*Kc1NNP`Q9N=AxNt%MMWFMLxXS z^A55|WK`5%J{~wyBh&imu&7W{oI<-zn-O#7%t`hhtTKYozH*VA;63BCeD`KooTfhP_Onw-!y64cLLv=J9lONs%5w2w0 zaGR~niJ9}_%+}(p?XSqQ_V!_KCf`y66GoKh=-c$vitq`2?c&+sJ0JPqxi5CGSyT?^ z*S~-N{#`DwrvuCVd|-3`U+XJrP~myoF~VT*;K2p_hdIwquH%DRYNfdCA7*6|Q625~ z;`D+Q1qGAwaf{h0H27IPC4%53!oCupe=@b}oZMsKJY^SFlQ>d^H@(_tTS zOP4Qq7<;G{DOsuJueL5-E>IB0|MSn#VZ$_8hgh4(?WBT2#YDOr1J4;>M7w5bEru;F)J-J6B{^eEs_7@nL<=n+Zvb=-hST>tPaunQFML zr;r7f(Iase#JWRe30CJla^mVE@0C4Ff{ z)QQ=T%gO1_&uA7lAyAA;u&;}2p(Bo>kjH=Zbv=8V8U%PDPB}coA=rcx4j7bzBC^8kuY_N?OEtG; zNIRgW)Jk>g)-8UWTHi8}ZaSUL?&H=g&79T)xNE7(NV6-rqUSGJGBC;YGo9Vt0?MZb zJo-1j%AvEiLub=IUn?q7C!8?j^C#PfYbavJ^vgf_SIa@`TO~L|HU_bbo9lMu=+Oi? zp+LxAosMHP!|e?ZCwH0A48UsUmSRhRA;ncl`pcf_Z32&ZUvH?{paDY)8nH7jQ+k4U z1n|fjr`f%W3$D3w;=Q)b@WF%CNd_@HcY05szO8uS%mPY}23>phEGC6o2Ufb=ZhEgM zoFi`m7zoJN6mNOy(xr$E8?N8FwU!v@Q{`TJ)~G}s?d_GxOws+fFPU^^!7Ej?-F`qt z&kxVTb4=Q{RUxrgRT&KT*z)PutcUw8rrp$$kHY_Tba1GHGvsP^_PT>f z+{~JS0oofHDpj7EYx=Oh0>w>cKI-+Hr319sg{_@acigvlNR?mM>&5}`lbZy@7mPI3 zd4AS!!`H8i$c!ex`|-Xk4~IXdf3S@Lro#)kxt4ku=j8F3_uG@M6zO@Xi>b^)o^*1& z&pH4z4Pl22PpJ)2iI!Jdc&jQ79Xf;n8%igKE4F7G&Nn#H#WytX-R`^hL(lsRpJP*9 zdH%drlO~(zT=?6~EY&4JnUf(OhH_#0k6|s26cHh2&3dP6InS^p-T!kK;hHkL$kF_m zH)VV29)C`0!Q$I4W?RdxE;F2hW0xg=*(cSx2Ulttu@r=$xq0bMfq~T%P4;dzAK#d| z2CdK@(tTvA8*#%V%XSHgzl(R0>kZl-iz4f3>DvUB%)>{018L|s&LKsgfbzs~hLcnx ztqmfqU5<=C?9m!{3lc1@XLhe&`l7e4oQiPZJB=}QYnE$md8a`TzMPq<9&T?J7?>Ut zpBxIXx&@a!fAQiZD&1I{`VAUf&C06p?d=V3+MA8neYiu9-o1V3loSeRzAkS6jOjG0`TMtT@A7^GV@dh->enBT;F7sw zT%GK@2?Nyj{{1(C=R8HX7w_Kz0ZoxPNyx8h@OL}pK0c_;;D07lkWwdACUvo^bb$W7 ze(_=`^^Eeo4N4r7A=^7= z*^s6E?mc-DL$B*b^5&7CUrWQn!bt2_o;>OE_>f~}b0aMsYyQk3d{g%8bEE>kJ5>4| zJGN#`ec{tMzEs}sHP)RvHQ)hqttXX?x{{KTbx^gQb`!TA!>QjtfB#-W7Y|Wc<@d=3 z^GH@?II5~l>eBkv&rTlrQ(S|GTUjkx3oo#M>7q{{?^au(?wg?r4DxkK%{(s6B2K2yfejMr%Ru;K--MT6i3QiRqmCw$sqziyXjjcl* z$BomoO@84jAZYSrgS&U{^38s)@myW@IdMq>6d?MyR!z;%c`skS?Ap6`36GhWGsL5j z)!AOgq?|c_{dM%;e-nvc3_<;MFu!Se`-;Hx)3Tb4*kdhUo@CM<&I#d%ImX63(qE6f z^;)*Agfnj5jC%8C#-l@%)|@!eQ_M5vR>FK- zJq9l4o`n#I0#>`DYSJvdw^u(?@6@SNXFleKAzRIailColFDG9*_=dK#>!*rCMy_$} z<6jo9w=y}QHmPaD4w#Ng9=7em&X}04{$-P?yQmCLR8NZ3vAUNZrQ4KyaWZXyBW{CZ9P5X2&|1; zwHn4#0xoUwo=l`gEbjl{(4?J=LLXss^39?J1x;r931;X}HnihW!I8qhaV5uv}p2Nc#i>D82r_t2YCO zZ=UrTT)e-H8qj$!Yw5pinQRHg$o>xujI`AG=U!s>x06Opf(GT87Evfu)hqvgE$7Oz z{g7?u^$bdHcD(6v98@)V#*D#y_Tzz%(gPL}rxy77Zo1I%VavpmikY7`8#zX~aJl-% z-#y)k-?(iOp67izbfX?1+NfK%O(`j+ihyqKQ3k2_>j(|%`AvDH^B9OB;db#Rg?#WE zu&HLu@#(`Ahj2GjR(lr!pQ@4f6$d7rZKl0qQ%@+pO<6P1=-D2baaXTh+v{RVR%mBw z+1$s+hYfH{v)49X2ljf0i6;-FABi*#&Nkdy2oh$f-TL(C-4BAQneQ@+tcpGVOI#Dz zi6>^Y`+Z7p%c15DZM1DU7@sB;$8OwcM{KJ?;!`^I{MkLLxPM#DX44XwlYm-rztY2V zhDOz&dA*paD$}cm{cyk89MTBP69r@l`uwG7ox=MOCMONl^&OWshe)*MX&g_#`jkwd zI34`kMrwTqYl*2KYv|suUa@=jP$4Agg(Qb2>Ivlm$+f+Ur*aupNr3J;d6sL}Y69wv z4=<^FJ-LV=d@DO!90SRa#CB3nDHl%Sk#Lv5zUtrky;26ZNRNJDtZR3iw?T5y3aDS& z+uQagWJP1nD>P5c#C>Lg$`zxJ|g!ng`(HL~jKL%MvZ5Ol9Lc1!ds7{_WYe&+Yq)-!Ab3%whyUCUw*=IjJhC>>e zG^8mAH@~l^_;TDhHZve{=budka1L%^O@A^K!ZE!ofLV1jH(j zHr=OdQgDFxUw-_U4Hr7@LQucL!a^oDtfYeVo-rdP%cpZukBw>?oj0nj^docJI5t1h zVR_ijQ>S`UOTnbP-@V*9?Dfdfv2MS2I?U>>uC8vti6c`1kT$p6XQqD1M7y6ANT}=E zX<+TGFk2hqY@c4@HZl*m~yBRVM zyqU1xBub)i7(CxGzfupry67qZ@r>NuSX^dafBm)lV?&MH)?+h&5|wS)moM^KZP^<% zZ)oc%;VC%yS4jqZwUTQyHR3kvsJ!bqb!ejA>4hZ?G1gqXa>W7ad|8~&sV!P&V-IO& z08JE9-NC#n2*{pu?jB08F;*oKDh!-w1=UoiJ$LF!H3v#F(Q?u0vBIsU01p`=Gjc`k*MKnMXGPkFw%A zQ5%v%1mgwRwcS|1N7m0zL5buN*F<&4D4jxd;PN^p6ex`wH3|hPllqh$G-ou1hN7~( ziVZ=D31;<>ft3t+zVP>juU=gSU>RO8IfFcj=Y>^pJUiLOpg070Ow<(lgP^;uKc=~U zd3kyGZZ?yPk=q(jb_|40DyrL{PImk95QFlNGS9qk=S_zXdvYQ8g7vD&Oou4E=^wOq^=dVR_<_;mu7nuO(EHrWME#Q5W{<`jT3Zbyfs-V!J$yL2CY{el zalMCjLhVM4F0zdPRad~HZ(!5*38n zf$>?LRaI4Ozdbusf5!mgpOJ59S+Cy@k0iR8(SF`W!K9w}z^ZbiHs!IWwkG{3XfpHE zT7Kn7M651L=3cr!GQZ-rcT2^=0|yk8mw;K0oE_xE?c2Ad_Sar9^2@PZ5uqR-;a|U$ zqmr|?07?FnUj~^94v!in2HXgfF>#?l2-owxv=n3UAjO9 zuxA*_5s`lR<<5Uf>hI{#t5-AFT9VbclXIF=N2|nB0YL;fd1Pd;hfrni5V2deYK07} zT$A19TtQ2s>++-tL9=3=DYk z?3q}vx^?Sz=h35U85tp<2jN@xk3D=F*W2l!Uwv_FO{MFz8Zh(b-MgrZtE(Is@RYt# zHU0ed!U~6C)_cnA*`$H`T^=RoKBV|;lCtdF^dX1hV;^`Ug=kgwR@Ko6Z>0hm!?w=CuZwn$Gvp@`XG-^6Bn7!?7XplosIQZ`fY5{EN|efJ~3nmp011mrj6sn zxuA|SR{b^`^!B{xQLnlt&U+GJQV{6tW$yA^nLg-dDFtA8aIh&JzbKs!_MkglcqI_d z)DHva&Z&9wN+a&^&hHibuGmI4Zf81jZymU9A+VtMno^eqT$(U&;41(AcWjRyJt~wq zreenDG{9)3VC-*0vWyRumqcS$X3SxaYy|R3xSkN_H716Bsr^q4A2y8UZY6xx@gzl3 zZq*ma#IB3qxk<@{Mko3z!E!QSXJvS}(q4~feQNZsY_|05pN~pO+T2Zlluh79*lUzt1!|6IgZ3T6;ON?whx7Bg?xeAf_l`h1($qlF2x=YLn^r;wPK; z?CGq!x7eHdkFDZ*cFA9g^z?M$I?DR0!lYlB?9gBl!jzYnS62&*gmFi`Y#%8_QPGG1 zDamuqR(Vb*W{*YAFjv)|mBN!&P(Q0{Y8FxD>2z>)_+<6y?p?bgNG5JCsUgN0L)6g*L+joLTO#8D-l;1XQ)Vg&x z@7ibCH**f@=J#rQKaSJxv0>aMH|>?*+mCMMMZ)avwKW!0O zL97SX)~9`oHAq-Of+9$b^00G8v(=RC46B2PI&k2?aLpVd+pjax@XpaxCD)X zoNuB-qy>Cw4~4L~<*vHfghm7Yxf3YUXBOU=YHA zYQm65`u*NKJ9YTYiO^FS2vn$A<<~E`oD#rzDz3_p%Xbl&~?q#maB5Lwcloq`H}<`IWXoShh`Y>B@$X znfWtIh8xb?eDfRW*}>6KdpytNkeA>RiI8xNJR%41mP1v^0@r5+ z2+z>+$%Iw?(HmfR(bp$WpFWV#F3=LGnnHg!Vw{rK>WAq=qLljg?;o~eMf3ha)*K7{ z<>{R0qe!S&ss})Y^05DgHVx5Ro8m;>+b5{Hk1(R#xg|%q+-q^}i!8Kg=%jVRyHH9T zfsf<>RaTY6eXgkZb#GsnA_ZxT=p+1`+y`0@x&!G{M&#hWi5>iTRG00D&KnCf;9 zuaxkh220%T84O8s4GNAUVS|+oP%(MrFtJd`-gIohU-SyV{dNjRKLuw!3ue}humX1a)e z-EiEtF_+mGdwHTF=&@%7U-CTYUTp}UFP$5`y9}zV!;hQhG&J1wfk$wpI ztE4fT2UXw-jqGLLznh?gLz7x`t!0J>JG3!J^xmN6W0${)+J?|EdRUcB>&bi(QFha3gN$LpA67&=j7;78X(b** z(P|3yP#UdCcdF>GT&2y4UjmxiL9goqPh!qRFYgk z>br97T4O!Eh=T_|P7EFe@gYEV+)*P=%)a!f^H3E!&6=&kw8Y-n*?S(qW<0<`jxq7% z=2s5qq=1LjfG^*I3?+E@uyyMiAe-o_Y!WObr*QMq{)h1*jXmUkk#vG!^5xybj$!~{ z%UUjer-QEGw%@H@W?)=z^dz)bG_3*HS-Y+4*@(hvg8&(70XXm}vt~u5rgos(6muG? zZ&%t%=fu_LIa~z{GA8p5potydzS$A&It`MOmge_6S=UZGMCz-cYJXvHTvHu5?$k8T zpFcnLV#g>9O|Gd$8kc!h#JY7`PkA=!;rt&|#8D`Jv<8YrJYYIqJX-ntX^I)?%j@A} zL*I`rRyvzV8ne5YbiQvM_b2he5{T)H=tDD67L$u!-$kZONQ!=CSB`U-x5Tb<`R?7% zyBplI&ojPi3+u|LQl$)(Bv3tKZNv0WZf)d6R!b5Qy<&s(b#<>}3dY^>H&t#R4W%J^ zftwz`xDc$55e)GJJT8VZ03Blsoq6IRTJO!vD=Ma;#kn2!*bV!w@T!}b{)wkTOu*96 zB*1=0cz9jXMh0qctyDF7rKWR|=ll8+`;G3GpuJ*(79%^-MgG*P<;2-GZQ4)< zw=pp>;d6z`tGhhVepg&tP>_Lh-IQK7;!+V#f{gbUSE2Aq4yDK0t>$2@;VzO%0BZ=V zcMpv3E=5fD?oIGyGDBu40a(Fz^nx(&V`({(Ev$9>73PDfaB*ntM+3f07w^}S#}7mS z`|#rISdY`0>^3HD;iS1RN4N9R?f=v8X%T-BqmU?W&`Wg+m|u78>Q&yxth!`g(#b)e zN2KIpJqz2pvn7oTo8GIj3lgA9bHBA!$<6z+H^=r*apf|fuTrmf@7`$mQimWRydrnI zpPsM8Is!~h#~jd;2Z@W%;Qm~*dzVgAGo=MIzceWN)8m%C=StB=^5UB(p-mgNZ}0o- z$6|ryl-UZs-g8?~weN*Kj1AH%!z@Hiu&KB-%wR?{3p+>Zm~DVTa)W3?8}$1RL}elb z(yu;`&l7T>i(2kt(})qO*;{w*y2V2k2N_V+9w!pdiE?x(`6JZtddPzqgBII+?#!$k zmRYy%W5C{<+~Xz!B^f>;UmL$;qoz&6fn*3e3c(mi4T9bR9=eN$2mDrY_&coq5KaO5 zm-w=9r4p%>PJ@3yd@tE%it_b+0X;d5RZz`hVq>RGz{Pns==U!_(Ki6eQlB&KZ?jq} zOG`@;U!k)@zQ@h*{q)?Dj5U<=dgZvS%HZ7^aA;hnIb8&c(kyz1de&fetCW(+l`HEY)HuFy89=EMlBuG6YqymyR|g19NOF;& zY-3~Nes1Yj@`5;fKYaYSV9AnXvOsK5OMD)_zTJp~NkkxQRH2xa#kGCp#0eStGH(3% z1wX(21s@>P7#0v}u7WpjnM&uLk0HWtPE_2$cr&tIDSlesXxUdcX!awGGzlX$bWw#&#Y} ze=eVNdVVM;;m-Nx%NnUv*#Zt*_L?)9?V*s|O9 zVnlLaQF%H;PJTZf6CHhla&Uemf0$xaM#~E6E0b8kUx=z64_(6YOyfBdq?GPZoXNAR z+r{zOzwkI(wu?K-INUp&>8& z)azTFRUIxLd)*|>Ry!?zvhYX9>qP!WetzH04`^dIH@TH;$)6HF?NDdz-^!QxYH?1R7DW#!jUUtjrvj(yi=#p$4#Cz zY-61X#7hgT>V~{3oB?Un?Sm$v-fr9o6nUSKT#!jyUQWEd^VtC(}iN>uihsG&zro!b88;!jTE#%G%x z_3iVpC|-kQ9GB+XPTX)D8gbd->yi{eZaZ@1NCq(+_gm0|;~wd4i}cxOS6{rCbf_&; z5+cCuHd#|04TDF{)73;Rq3WOMv>>O%kAiNP{6RJ1ce!$q84o1n z05y?sE{0+f2h31^&U{-mGoF0m%a`_0-wUfggzq{==gY~tFK$xaTJ-2~tJ_$Oiz*pl;>4X0Qg@Lug#jOPC0h;bH3U#6jxzWyN;o`6aj6%pz=Okf_uWcFiDyV3 zeu_8u_i2F)buHqjfb6fbqdJh|B!Qs}E3h;-AoGbojbZ@bwalqQ#c9^B-#K%Yk#@se zAGqS`CvO>>?^lLH`UJK28N6XThB{UWH@l2N}z;qp4)AX#Ns23)naDCip8D8N<$ zd2{NZ9EV}Sb`ee`A_~~iXh)lP7gP4)^+%7k zc?SO)J-4lE&UdIuyj(r82R7#Q$n0hFs#r+w3FS&r5O77uTW8U z(JvH?Wr=0!S*r#Ch8-inK97F7nRubEpMwX)k_uc1Qp&fC_mgBW=2eh;kzFRmr5B9D z`1T#0N|i~UV%)l7XQSJsi2&m#2nC9svmQuPkhwA2bB0y!%A2DLlhKZtN8gRqZ$g7U zKGYhBl2zQj>3OsQvNI$B${Hb7ay0?5@DqEyM2U9vJdcv8B5Ba#NEX&5yRM7;=nlu-(= z`AdUL%0m>yDdXOApGyxNvnC=4R5vOv_cl4gW7EG^}_ zR7BF}!{6bZN5M1!6}hcLrQMJ%nVd}Tq@n#8KB~*SPc#xBvaMP2IM*{*W!gE$p_B>oJ>$FBgG zsW5+kB8Ir)7Zoe3o%%IoYl{O_vMb$NP230T{~&xre9(sL*RO8|IFLy36{=qNU1Jr!Sb4{f z-~AW7tRut@`#@p^Dsq?LMwd)b>{{6b#!yCp@OJ+7t4!AJ>{$`G6;d#9jeE+tqkDJh z(=KWS9?K$8=~?;~>0W49c%MM)iysUHde_Iq`}7zI?JbUSTyhHHdJ!`+Hv8qYK)n~! zEE@>ABIxsMZQnsyf|yQmF+X2lp{BOly#7n|strr`Kn3H8R-wpH2nohlbNoF;$*A1+ zqH(!xP1}bm;-Lm%R}zvV*Q~jWn*ga(?2U}|-t_itu5<;6$OJVJvtvipi|sulmi`no z5C%(QmRP_&Owwu&O85U*z~Zj=Wof`VfYWI$ybaXDrZ=et+*4g!Y#ihGj9dfH)V^=u z7EntVw1u7atuhbKaq6e4kQhfTG7J!@z|YyJW0J1INLSrRx5(M`@}>V_?V_ra@w75` z>Ewmc^K6%v7u5?54P|!y@B>@^nUYwJ^-d3qo^-NNUPuiJF+wZB-*~Qa4}~0Tqe8xJ zW$hmgIT!eLsJ6}Bvn`Y#w$#T^n#o2Yx4Z(SXS@$h!Cv%=YPOI~Er?oXYpvORHoALW zZ!BCXz?&lM#!B%te+WL)($W%XhuVJ}0AJV2&+t2h?|hi0z~##!PqfIv)RRX5|DQ+1 z_ApBq=ax7P9liO$pw%2(AevqV@qOA-oxB&4~Vf z&S%u9QE5vn%&>^RM21!fwnFZZ23!ogL=@SW^g3GT9aU^>c5DY!uXN<{5RBAxwBLOX zfTSS-!_P2IZ>^MxL&fRbIKUv-<$@<^7ZxX^8pBc>jc{eQ4R=X(=(410djHKoEE01Z zUbq||Tzq2r&n5En4NW(DW!$+FO{;`RtYWV8O*hc7^$Lr^=05P8(E{3Kp1*j}0WAsY z;dXKNCg*i3^wjIsn?i!&2p)s5sQn0yrMNTr9etCq@CCMc3w9`yIx-l%QNqE4!_oDT zfV$w)2z=k{`Mh3zBCoZ}HoR)<@85@5TL8*c_-ZQXWtUr??h?u=5kmb+llKO>8wR^{ zDTM{+L0*=I8hBFBGgaaikhyGYcn7jrBa7&qslC+~)9fR?Bs{*G76Nm~=;mWCnoXAI z&O(=!mm3)y*8w1;k4O$Mw(o?Qmai*H)+zj>{ zS^37-*2|VHBOhSPxmDgW^UVECv9Yn^nvWWgvb~r~t)vcBV0~b9l<5V#2qqO~0>yNE z(DoO}(b|n2tbDsX| zw0;GvK$?^SfCOTstK;Il$NC~w;8$IpuJbz2nl^WC!-$~2!-im!b1G8GHhEYN0}!*? zJ+Z9%0BR95iLwJ|KFTJ^D&9OfDmSif{Tc0OS)%2t=`d&zv#)ijVwiB)_WyD{DUKXJ z?oE9Gg3})`;Ig~TLObpA#O^I02WRJ=;l?Q5-(yH}}br1pj75-tR0h z2i>5|5Dx*HMIo+5j3gdcY?Zk8U?B9Zf?8~^hf7FGNjUVA@QI%1(<4Ha2eX(%i$be? z5KVEIDA%uFpN^8%ICc@#3fYkCaH(l=Nsgcn5B;EEtd#{h;b>7oZk8F!gwq;6khQVX@lM>HI0cLfC8 zunvUPMUETe*p#K;iD@^U$vIM+(ji65V?2r)s!u^df!xGGZ*)#l_h!CNX^RqZUXc8; zCa%;kpFVv;4{QRbM)C}!pPVp^Y@yIzceC!gr2$+tzMU`tLb^=N%bSHotX8%?w-(=m zbO}*RT*b{sp;T0!TQ49SB6Wl5!ouN3?KRqrWGXelns?Ot1EHlXFR18zQ+#dt`Ehvq zFdC2eFU!xf{V_3nt5E#K6fP~85IcJ*lgoXmoG-DDKruVn4zzeUQOwg>l|kbJ@F*Td zSc(TB;?WxjGHWUSX7ukonZSC3vJ@9$5r9U-P`%7o4pr)5__Pev8&~w51i!()O+o;a z)?*?i-ml^uPmE&3Cy@;p{h>BFF~r=brIii zcyNZ=`Lak{Rsnd!*O-QItJ;q{d3A>@#E?u|JJp^xrNRqnapkb^B1=F)q4}u9v(Lm?O5PLOAVz%Y zrlpDJrN9Z9!H`~mmO(}OWZW%OcqCUfNW}rEZa3q4<6wta=-cNg}6)*)rg1`T#?oz9g(T$ zuKjP1%Mqp)z$1#s1)w|yf`G%?y>}PK%E7fB7wHTKD_c3P*{=yT32?`%U$(UD&Gx19bW2wSWbyr-pgf`j zj*TC&^h=Ca{H#2qKfcJ$f)sAu(gX;hTq#$dO~IjliRKpQMn=t#qs~|Z%*Eew9X=CQ zCEm^K>e+bJP4DJ|hH`8A7~~0xD#mF*&E#e`zeAH& zL?1_oj99ZKt9+OLv+e_C`9MZ@R)E|0;@srvS*}(Oh;uv7$9l4@zySL!Tw+hoFSo+aV{Bv; z#u-}kbCR}(V&p5`I)%qamd<|)&&f%V3u^b?KdK$qLLskH&LC@PdvVb!d`w==?w3BDW{~ zFK!Wi=l|6w^6k;V?Ev*+r9<538V|WAO{;clEgY6Qi^T)l6XDI3iKY0?-ZF{@3@a8s z>XfNJe-bwW&VGV+9LZHUTZSY>gj(NX#0o5^h1V5zIME`f$a#mBeoIaK9>LrdNO;VJ z4(nS_tn4v&?p%;wB*m=cP{-pcOn3j%gP*8cpbC$o>8wT3AYQj%7C0_8!O@bfMCWn}WTvr$A`qo!#7hTN9 zunYpAP<7O3)*ekgLr)tGPQosTxe^|%8fVdX)z(28sl%&qd2pS`Znywg0f_X)zAwA2 zbl$RO&j=_sahT&&Zx06{O#m}z#(Mu=wKTtwDVRb0`rP9Kq>y1VND)c52ulL$T(EFq){>nbwKH`#wbT+7g&J4xB0e#j zuHOH4aUd__;gQzzaU5uT5Ndg?RS47q$F#IIxSv%md^LF8#h{>|VY~X^lx&UPFN)R| z>$iz;^%6PQo0*@>k{LNJ^Qa(^RX7+s9HK&L5tAmh5Li&iHGDU%6c~uuWkU$(`F)R6 z!b!Ma2%5C#fN6`^FNe_Fy5XdtdUnQ@2UXU9fxrnIBHPH2VI04e=I5Z%!9|Fzf!j1TQhO^~ZoZzRC-{xx;xgeK2$=QHk@{(aq?t~sa1sMW zq%98iO~=fQ#?^~h5^INrd~1d0MO{NfupVRq>~MHmTGe)&<%LbAO`R%=rzlM9L^=lL zxdRsYHK_ ze@Iq2N=q$;k0VrWaXl^jynSs{8a8Z5@xL0EjdVUCh}2DQGyh5Q@Rm&29>N@}HZV|xU|#Hs9)WkeVc^pc*9xDj9Fsna-e}8;WM_Bs z>1>4HG^y#Q|0fS%hc%qHgPi@p$9 z&n(O!{mYc!N4uOw+H$!w(de6&Cr0s#|f1Ir8cYBAf z@Ak~P_Dg7tKTW{RB?3bt7NYx+pP2dVy!890b(pQ9d(NBsSg+F zHjbLT{7$!n6Pn^(8eBC1yWbv>;d!|*IE(|A4@`G@5iJWR(@vo_tCaLLfADR2ln4 zRND0A$G$~6Fw<;7Hl7zZfN<0-t{<|iTtwL~^UpXXyYV2DVULED9n1#kU$uNhKUG;& zswW{#u#w-69Hr|k<_I3pROkQAg0VQbB2c<#DeQ?&Iu!#NY>kf2phn6)>(>Q)KwC-x ztaJz>cEIV70~YZ?IVQ%&lL;YDBYHgHK?(S0&q`+qfCwt|G8nITlEr`fE;63I55;Q{ zn^-rKVj-4hGb~ik&o6K3?3^>Kbi{>x8Xb@VlyatnGXf_BB3>6q**oy zC-m|6+}iaSF^&7pbtI%&Oja4=Jrf zT>JX&;hHN~9FV{=@Fs2@wXaj{;0VHcrpN#0vpD=r`j1%~?LQu2*(^X)B3`>^J}XkR zH0&=LQ3~5DeS1CNHzPKz>D-{|3&^_t;rw^cMBRu=b=1^EE5%`3=5)QOjn)cm2RCZfYHet!5~I)9T3$Xr zCcSn3@iU7W7+y_ZtuQxa@HGF=MhMNmn)n0k^OAd?6@ty&iwo2zRx zs&G_l$vaACEN<)QQ-L{=nJN%q=rgtU(YHBOEZY&Us~XaH0(;|IgcopM&2yf(&;$Bp z5@4uw6!6Rk0!oWpZ?-9Jet}61;z!y)=HN|AAm0xyR&MyCvZ!@2sgmTY)3z&E<3ID3Y`>jNRo`Jkn*qPCF&0m{%5XrGTTP)-2g1l)I?|mN zLoGO&o%mWw`l^J%Dz2AhUz51!`{m1*K>)8fED9Pj8e(~16v5h~M=cDVs?|w|Z!Dt1 zWI(*EDuNT^(Lw=t_|%cG<$^pHuF@^I?Ah$UxC`!QS>m!e+E2W`IH}?1R`JU?(BkgE z_~gQLx(z{23hB)3R3k>-2c;a_}a%|Fk1p?R(t>Iwj4F*!p4r!UH@ zqvi~~it61PH(tcXn@!arwd+W;t*na<4a>BWy*JMf)^~j_0-TbHs^SQ0d_eEchV!sR zNW)Ie3!K|x^919v&+cLBA||GKUZ_#ipLoSK?>~Eb-aaBKjzcE+!(Xo9C^5Mb_OBZ$ zo8(eAVz=8DTqiOlJYk#suM}sT?z?sw?)*s#e-3WH32Vrc?f^7@M|xaKC&{JXI9a^O+*Z>zT)y1R{ZU zcWtw!{fvec)@|V2sEtq0FI2`UyzRm$rc+9@@VRsS%7Su&D_%9E&V(Of&an&r(DK+r z4wX9hzVwIn0hKjr(ISe@E~;DQ41A%O#_lodV#Cu4FX~Hk&-1OwG61-^`}?{`gAY2R zt$#29T*k!_JC$7^>#)`eEt79)vbFv%Fe+wf3`e8LwyllH z?M65JRb3rp9nh`pOgGq>kuXE_#0^Y!b7d%kv_nXb+SHDw?9O-Wo-F!aCU$7jF0-WuP50=b9M`0W?ZEoB$~3^b@& z^W#_0|Ic#KzP-@S^aEWd5>a0y4BluYjts2IcoEyH#ud@jGRYe|f%Gkc^L=s+2Vobb z=D+|PW4SOn{RabTA0mHUeDtVSZ)eZU|HImwfc2cW{olVz3k^!hGL%Z$vt&r5D6*Dh zFbIWggEF*8i!F*ok}V}!nz6*8fOa_zPbtvnS{eGH>12wM^Yx zQo&TAPzt0TRr(OoFj0t$DL`&fu3O%L&*OLD??hB+{B58eK>o{e=g?B^xU#Vr2+}4Y z8$6ALg@K`Aq0)TnMg|)9LqiIyl2`jyl^TnT6NGUM@2uM+?R81Rzm?m=|68p^*`?!k zx4RVBQ*=qYNC&5*s~bewCW2p1eZa1`?a@?JYtihSh8Uq0=={2NfXT`KQDM>YUlkTh z{%3_nT;Ci-mGnGvVQ@qs1<7C;LQq;q2@F>W>4km$qH9dw|2_qq5pHaCBGVHZ_l5~f z=L$qB+AD^)xw_J4ahC}JN}}i_uUkPB)PFkvWZd*z$}0|j^|42Wz5^TN-RriZvdo~) z_x}7w8*EFY7i7DM+_z_z{qy@dM#r>4(1I2k^)F+4`Jez4Xsp=NhEq!PJPU77mg!#|kW5QOd&xj^1cjM2!?3NF-}KiocjNuNL(@lnuz#q3C=~az zCySZt0%;Mk9Z0isj(=W0iS!BNJ61ey5Kz(Olr(3cOnzGO>>BwF<1HEAz*QL~Uy}f) zXejGbb8?(>s`6H^ye~61QZ=Ar1G)42@>a`of5Z4k>cyjxp| zmL|+2{*t$eez-KIq^2sPLXs6y4}Ah#s-PN|V1nKu^WyTx-rvU7QjdtU0OD2HGZhfA zhGk(@$JS+yyJQJyilj-Mi7|yBmOScU_eRhk(q%dXcsIz3#STCShkmPf((sUBV1Hl0 z$ST-zA4(nX_RocBu{l#v^iJXPNw-InTi;jL(02!4%p#G+Y&*XpRq^UCua3>5?v?C{ zLa+grOMLdAz8ay!6|e(z9xsZDs^*%GuAKF)1S%Q+`%iY=jcDd0I7d1iI&1-E5}reCE;73URH8HOvz-LZ1a$suM4{LKsvjXns>I7kz*LL~m)_;Ri|YAl>f zC#V6w@umom{+peg`Eo;sEx{MXOPVolZk){Z(i|8(9pAY@%qrA$+3#*^UWH}$;cFRH zj-_(qhhU>>3=H&|BqbLEJd*J|{_yZ%t8u?n^|%;#{hoVsv^Ag!@}W_P#OfF{_c?QH zEVXZ-I$a1AReniH7Kv6E17nUo>m{q&^Nx%0Ytquv3OICV?vfe5m!gCa zXB)llhK6f--!CZSX&kuP%-02=1PJ*$+w!mfLoIKs_xI z7^WL~Wg+f~!>D=HlU8~Bi>{->S*Pv#BSf4Y~AH2*X z)giVM;~h*%Y^QD8fFagZ7)COi^u(O)z+)k8s;a6^Bb*SJlh|J-T zRX>}LpK(oz=OTU%ALCTtzq%cDgX2b{vi_(J(vR8=JbZu`h5*u-U-qcF*~t1@({IV( z-k4l!ivnvq=7r*p9KoVHyl8zXj|JYCYGycj0b8FqQ6YqOon&)v@sm_+PsEChj%L`* zne}6w_mu9BYcu7~g{_ckyx_EmhdZ`6+})al%2&r;ac%D*Vx~8YIy9{7r8!@#s`|LU zu-UwMGXSdHUmpz$ntnU@dc!YG$fu_{fAOL;_DtAB-EcGZ?Ft8v9WX?(9sX(5tckw! zQiHbtUn)k5Ef%CypN#8OVA)lTN>~Om(K$8>b5+E^XN$~8v;>P6|B$q5K&$eXO(0oz zf)V19@JV8%=TKitYp}98gg9jRx?*EJV5#uH@hDous&XP-@&J$pKtRNGikky7U6y`w zf|p3^VknXk{@8^E4k#(4ruv8o?B)CSO|3{6BBCJvXC^pa{`{1aDh~udeqi#^bu%#Al~;vMPZO?uo#_)?iQYnBygp#sT~ z$d;&>6K~be(AjBqR(pOdU%;~W`J;Dqxk9?9pWk+4Qmy4y@~1TG{9a|LKND$OQO#n8 zVsXR$P=|6(w0AClQ6z^_|A@|jyKol56nasl$UwNRhs)&_C`f= zaM$@0O5b=2k5s-I)lAFU4XQWyhCJQ9cdtrp{S>Vx2JRV}!;}zP1w87oiB^#VEUt?f za1^M$7+|3(a6X9&-NY-2Qm7sIwRAU1s(4zKc=2M0Qjxau6|`8bp|999x=Y9a zh_ySM3i=EG`q}|>PYtIKz1UONOXhcM%z7;{g(Z!~`z1_L1 z8g##USmBJ1x7ui_*qa48?L?-)vDOtRwk+ni2H1ZX{SGs$f{HQY(Un-ucXB0miLoh& zRM@s{opP%k{Q@7A2Xe&8ruu4!Uc1vulbanNiOkh69tID(3UB9XG&W%4Q-#X|R zkBm=*Fch76xs?uC@3|Y|T}%g#JL7Py0|#Q$3=@0P<0dtvG(BVjcTZ1h0Rvw%GK@rh zL=?Jby{B0&eRynllFB)FW2pXysjeC|=L{M6qL%up)MxveHaqs8`$qm3G>YGBn>_nU ztmQ+yJ^NxAx&09s(dd_TjSeWb%}elSs#B^L#KK~Ded5Fii}oAa_g}aUO$;?;KFs#@ zvc%8I5^%!z?8yZ0#BbsH>qL$GaJ#~1VAsT7fwE8}Fjg>cYLOM_-~I>BAk^^dyFs*N z7AgJd)Asyv)kQ)uigV5d`#E1mUhJK}wt;!o_w80bY1;!&C#|S0szE+K@SR-d&(~<+ zb&7377>asQW}pxXRDGiVzE7vaIzB7(Rwx8I_3hh&u9k@iL*tlNhQz>ENVc;7n7kF0 z{|*185Q|bELxFN-6XslRL6%(h+i!7HFc7ASsh$(H%|gts5600nK**fkp6T1vc8jAP zU=R|xLC@zr2Pgyaqh$Ez0K(dSQP zl;~0n@F4TNJBZ_A@JpCwvMUB)ba!a{<%vf&1}2T6bwxB#8qbRd7Kx}&ZsX<9+s=Df zgRe!8k_%mc!tWF4o}h(bn4iQdW-tGnw1|7X?Dg#qf&;VYs^Bl{q8ZlDs`vE#cXmRJ zQQe56Bn*>otPMtDE-Ze9TVJoh*^IDySpQ0=CU&x3Aq6U1I z;6YHF8?1z@gZx#{qAOSOL!3iO^NHBvwKweDN)z8+#qOPp)z@Go^@bQk*(7&MMpW0R$tbJ2@x#b{kYy(R|GsUF~pidcJDQf{% z&n-DLGudydTD#w~7XF3D8SJOH&J&yNurr`X20y_vD|%?;9_j>4ceYj zmxf!l^BTn9YhL**ClC{I1p>u`D1>A-196MY)BwJUT@=+QvGVml{jrD`q84`@8WTbW z^o#6Alhzu^w}_t@N)pczct?*PK=Oh|%x!9teuYb|D2Upg^P`jT@r{2VWJPn&uvr`v zV|d!EwuASR?9o@XD=57WJeg@;uP0pjJn;dK|$BP#r!|FkJnX1Tf!=cCi{ z=20F9R)1~!$R4O`zkK=f`Tf&K42m$f)y|>&5$mNcZL)LKhw6UZzpLVC$Fgs|7-4&^DP9VH8RKo69QKZ#c+=5x>VoqYlp(qbzKeiMdIGi0IfXcC|I)N!Izh!-bu8D8U1*Z~0dJwj~mO6u^7>7RM ziQnWgV?uZmvYdhP2EVP{HC1~{_Cil*p1ry~Y=Cf&A_8dsFp5UJK95`Yn5dg}GAM2|2RFX|Vf?bxBRn*c@`4`;YT`5MYIeo5#wg zo8k4c&b~MiHeeEzAmU#N+i|=b1vdjS{L}H|Z7UrV3>PKwPnC3kX*)Ky2?6@KI7QQ;9 zq1W}|^yhRAkPgCo6QIkiep^AXLyEvCshIF^@Lb^MkIhW(2>yqvtgwU)6)$NYXbcwI zjZJq;HqO6#H1hbc0}5yRzNY*Yuvj`FTy35`HTf3_Lu_%;c1}nb} zz#U2bE@c0#|32(K6Un0QgQ7Wo>Qo+@2D+P5(0*8SZ1^`>Aam!_X5FJ?4_?Q(-(bG&OHz>m9A@9lF1QFC$mlJVO^Jzu0Xu9`7ntkbpj(xeRWF{AL3 z-8IqgbGLmpLcc0XDWGir{}yat(QZ3at4SODurOh*1gmR{3jwbXZP5$LR(LVH@#Alw ztxdr69>JF|I3!G&)6##daEgyDJCV5|%p&3K{A1MKoX)u{e52mwUbYf5byTPo568#9 z8x(hDT8H7sHXLmWf$jxjXQ^9$`!#@x7$Eeij0^Y=NfzK%@b%H&yPSR&0XQYU35qVL zh6cx;EY0#wn@}p$;7G)l!$8ndL|FJj*Ock%`}XashA1A`+8E@LGVfYpe2&tAjw zf5V^gKxJZxjZ&$IDK6KjYM8%5zU6WI1fG0|Cy<_hVuzkP!#{}!?QmYae3R9Ch>$P z-BY6Ls6D$*bX2)l9dlMWI&6Rp><>`iD=9^)Sis6Ux25O$Xi{DKwP`g#^U_eHzTxX!Ql8L*7j_Qit502LK63PYo3l1 zqwhFTT?;}hst<4jaq?!@@@(d05|?Wa3zboBph^ZKm!YUx^6b1)*aBtV`ObYW-@kju zqQiE`Sr3zO8mXxt4Qt7xaINNKd9-g|1=tsKMTm?vQ2xSWL#sbWgAK&#jJA z9ZPjNf*Ln%`OK?FPtO1F_N}J=qbl4CtU!*gGd|7*3+i-+4FN5G`|kj(OHv49hXbz@{@!m5Fv+Hr)$tLRLnhJuotB zbmjKA##^XfU*XAm5NZA~{4>tkkMUAp5HsqRU)nKkfR#=HEI3L~@gXT)n)v&G5fE?E zZhlu|5kPO=x}jw$jS5{Z2RjdBhEvWV20ImVX8r0mU09;TRZb_;^Ydgw^YqIt@`sNq zDdl;{1BWTJU6XKaOw1uFxAoLgP8@jT0BL~7V& zS4W1ufYM~jPGBN_7XfVng|EL~XWnOuU1lHZC&1Na5Pdv~G@C=y4?A?B4VPkxkV`Qu zXH_hHu7g?A0JUbA>B{5BZFpo8>b!Rm@BoCNpTo9qPsI=o>Nk%=MA%WP ztVlf2QIC)z0~FMkQt2_ifz0W~p+B@NC-Fcj?5N-*4AOElSpk}*&iGxs$^p&dI+T+! zi@OW&A#rBZ?HbR57sxGk}4S%{auCk6*sLLQxJQc9*7$AG;2j z8>VP^e6d1$z>ar%0N`Q*Xs4q?xMb#M=Z$5gAXam1=D@I??HUo6Y2?PFYIjPCTm4xXZu^mNBOcmUBWL?v)y3DXf!G6kV15AlD%xK-n zy5Icxw6ed~ge@Iq8Y1pxBo5(~crJ?i6TwJ+(}{p^J9DVQQr=E_&%xS+`4op3=d*Ao zNv~NLZ_HfxO8iu~VKJoooBM~fzcxKo1ZN1Eqy!OzQgLtK+<3g-w|<`?eo@*Of~4cMT)W|N_{_`CB!{A6g4E@9ukeKLeb+oy`^(XozU^{fP!%VFobwrnC!2$=L2 zD7_IF$pu*)g^(jIVys_VfjOc}DR z7#KjECSx|VBw}a*E-N5G4+<#`;I*9xYnp|9d-?Za&1E#2FT>9Q zdRS#&R8&!ReE4*~=zBRw_G?nB+d#YUpl6Zq%~v)}Jz|c|PwGP6s9ZGq;&$H#|G!?Z zIOS8-oKbevnRt+-u(fob&XHceBVf_cJBr(glo@#NFn)vTjb>kC&hhF$UI$C7?9fFf zaF6OOJO#%n+9R3+c}?6+B35tLzkd)_{hTc-<<*vS@8BdK$H&a((oy0tiX2V*id@vF zenz*a@Ns1%m@`N@F!f0IQ3hy{+lU18?$V=yaeY}W)S7g96?R_I2awl|@Oui((Kh3S z#CX#-f7-7tjQR_YPG!HprdM&$9$R6Y1J}H#qJ<+815vQou|R)qD86`SYR-{|L{FCc z$gx3mjy#>AdRt~Ble(V_J0~6lOv1rcHBDjXuuM`lxHpcCcNRBkP6GAK9C|+Aa%@0X z{Da$qLWbVT5-Bk7u~oN1cc_%6xA2c)D z1?V8Eewo~4*$=wfJ%y`Cz*n(N@hg%9h6%9-=Vaz*-}U=&Q)8O9rPI=%lr32wK!TC& zu1j7zfWeg8*b zkJugc1}P3VF&@KIcRCD?xZY3|d^0owQU+sfjP^^pHyyE97#6FxvpeKSU$ikiT!*JV z4;U+57ZeL1T*>zz zn?q=^%D~vfXp86<>H0|D*H2uzfKrh*g}?;mm8ZlBZH9ke$+515>JvF%Y}a3Z-4YZOR8x1d7jPtAY4R8O zu4G6Bu~Y|!kx;L`apmxFJ1K#vJ#%t$B*@B$4?#YRT46!JSE^~z{_+d5BXN{-V_D9L z&DW+2foj09Uf~GFCgVa&2uZ`p0j0%3mI2c%v5FzW^L}-hN5o}u$)cZN6>GQtQP-pL%hRP20FZ3V25>OO(hK3p^a?#*&!*Cpse9&EvyL~&T~*iE;JdSkU;W>S*{+30Se~8e z4kSpf>%ja1TTQAH$0MI1v3R@={8uI0hq2E8qGYR_{y#|AGR9s!u}Mk2D#YgpL?j7I zo)3}+p1~zn?Hr)aYH)-&ir3khcu##6THRqd2#iU*yKp_As+imDCDo_6t%&b`EMq-)5`AtXqunC(qM%Bm(cQBDh zWvtlP=8n;~9(8eX;g0{Kvh4?qPySQc=4RQc0xMk_aNm<97)QW@d*C=viM#+Cdg|da z1N@Z5VWe~MU=xQ4$2m)CwEFYApR?& zQvGXod4~iz7THHwKlx6BAu#*C@*MmlLl}Fa@yDx9tjKQUcBRZi&`gBr=#}gf@YS8p z>>7bb2nhzbs>V(>@NEL4oR%i0Z3w<;M1(+6&}H|A+oVRWo^UZ&)M?PtWH*^VM+~8A zeMcd@D*~@pDX8=)tFO?K$ZQxv;0Ol*nfWBYz#W&PdH(cgQy_GxmO#s7`wzum=f9rb zw{lEGm$(KkX@Xy^4>hLD5%9oof9}AZPb5<6!0mkMPAAz&V2n-}`?Q$t?Sh$7|0Z^u zj%sD}^y&MO$~~B%kUkNZeS7k!6U|1HzZ}o_278HQ+RnIlq4obLayx>`9wJ7i{`s~T zzh}r!72l~z%X-_!=A&!1x9SPrDO+Z1ThZfv)gbkYeBszBFibYo&Fj^yO#my4xKN515_7Pbn1OL_C&bA8e{ zpA$n_6Nv!qBW{G=pq9z>xdiqtg- zEaU=G*^^|imt(V?b*NHyiZL-P_BUWE^l#PXXt}H$r(y;xTP3mTdW;?nsG-azonIQ0 zG})XjpQN=99f9~F_mE~ok>*U+Ye7V_@XS=xR6XEa| z`hj=|N~E{JKudEJ((>F{S#df0h}saP&KrkM_V0 z@ss{&O)ty~)zQ+@AJ9w2BryT2i^_;_DPkssH2aA;G{*09+72J~A*`Klcz8Hee0S2N zWM-+uIa13JZh~K-C7p_CEEMIbgaqY;5~rPY#n1vXgQlz0QZH37dPBq)16^VID3>6>d zv!Ix`VG)y*l_Cb$0>(1ULErV#4cDDd4yJE8+so=|yjQ+^Ok8^Q-BT#)r}h8NQwaIm z@PbwkRByFJ560V}kv4`eR8Z+4h$*~Yq^}nHdVr%|E)Sz&X|k=8Cn{+XETcP>^>tLV zvK-@GOhj`5>_kgZ=tbuAR{lz{cNCTgFaQo)JVohI#$k{GTSx?sVB}leqUR18u`;76 zqc${C3NRtP_U-qY`m9d%pExrmmU{s9C>#le^jcK$bku{XxcRBD5bgep+2Q5#ME!It z-aC_O`CuPX-eY~^m*2f*qfRGTYzL{!c>;k?)LFnu6?Flx5$qDxt;o4|tL^=x`FvR} zHubWvISK)pMq~Uk@xJ4=Y1tN+2(18gx3ibj7oq&10cfg*op_iWISE9@m-$<|@g;;SB$1?x?q+`h@>2}hz zavAuoLx7oOjU)uH@Y(um`*a)eDr8g*at28^&H52KcNTbTB9kayL=7FP^UZ0nZ~P^b z|0_+KtX#l&bQ_G5%9D%@zda+2_klzN&at5*-1T^0M$**rG=OCaBerk>6ame;Q659u zsFF-&$27hWFpW3HkI87Iu}>a-Ps9pc-qN@gN61#nmYBsNSpP#T6F;vG{Wt zs^F+n6xr@wX1NVrE%24BR>Jrv0Kr#ZmL-w)mF5gpOuFMM_TnT^V(U*NHF0xG^yj~z z2>epYu4LI01uj*^-1PFQ&Fiyl8*)S78qkiWD1WdUk$g)}qMp!e-Yc}n#4m5GpOERv zEC-3735uwq)e|yx@XL^+1gd=c%#L z{ubItSX4$A#bPa4)A9Lp{Ta{P*^_>JtCErY+qT0~v{q?Z7_@8IYRu+fRU7RqIjzQR zzU17$o$AFFnt!*}>3?)%fBmD6*Y=-sYHiF$RU0L1hhp>B6+u}ig6zu1#A%o%5Uc`!vBZ&|EP7D#jp} zFV_VnndRdzl_EYu@-KiS$ZQiNg*=_>S!;lm@^K1b@JJ!~0`S-La^;KTw>uZLh5yP# zr`Z*)9+Yj*vzIlXzoVAD|EGUzQ|HZevtA!`4U1RE9&Fjav~S;!NLhm`Z?3D5H3xz+ z5>5fns@|Q+YGdwU1O`#o%R9DboPT{CW{R>Y80RuwyjPm1 zAUL^-!h)ADM?3mb=}c|+7%y#iD;blazd6h%E6@}`2E*i%KhBl#v}LLZCb>-6^Shdk zsw3}sZp6xmEiL}=tD%3XD*of-dA2l>oztlgl9C29m6kK;3l*v>jk6fE22dEvavQd3 zn(7%ohz7SsklN;SzL8qq(*Zwq6H1Br0`=Yi$A8SmaL#szRVRI-8#$kO*- zi`Snava-jeaKsU>s+xhkxsxe*vDg<8=fsbb;>Ho50^t(?LE7NcGj-}zMh{tcHxAx4 zr1a+c3hOjwYXcYSkDb#4c?B+@Mu1t#82pK^U6%>N#t*7KC~OK@v~RzDg0y5Xl+~nW zMzNDH37n0Bf`U^FH!6qkU$=Gb*&!8t^__e7Tu74G$Vb8+v&wR6jO(Z&Z9Ahnpdl^; zdId3F4^+fa0&P?*Ew%#F!2Dk3f}vVCFiu8~y4HARhu;=N8iy2QXjB_TfH>e`jQznSE7FFj0z; z`HxR^f~FhN*dznEq4gD7Z3WRrVEC-N5c$QNzpiuw$F`t_n^>0c@S#nMIh^7C9 zRcSr27h@<)?_s5$Md4T9cjl-rK5Q!>dwpc{f-uyV>4b*9SEu)#%aIpqg7m+A-#)yQ zIzp~=>AiqFwuS32Dn+IKw|PIO3dr#5BoJTeH!ojjHL9W>qn?oTBDoDJ!uBE9Tl8 zaV}K2WOKC?o=oo7i`jS4a4huj@W6*)-L8FQ+qP#4hAfyDjU!wF8F}e(AA{qejZUh! zBf=H7T7f?nuXx+mNhjq$p=dWWiovVb;T-9}`;4LES16FblqE*`;Z z;XhmAOeHUf)GoD+Y*?WSAtSl6p%EQtY|6*fBeo2h@nb>L2{FQ#lfh@to!j8tgJlmN zSS(4)KE`(R9c1&PmQ`Bdi_!5;$|u8v^H)S`>zAB}N3Doqn(saaa&mHVKsL5>MCn4Y zY%iAX-RYMsi{NbkWe{0cSJUJ>{ySOS-B_pCeMc6IXQDE z{i&?$LC6Tn=FV?GCS9H3JfRMRef4S)Ym=yyY#d$s7^JhXc|GriC#!BVber+lmyh>z z`@Oxr#X`RwDN!L8%;EmiQV)}=U?WHh+zPEPee{c0SP}O1|(<0={Kfc z_^s>s@#6&=XPGX5o{-K|;0ASz1~y!OD+P5R@7SxVtTU5&{yzJL9gyiIlxwo?Tr_Va zZcU0J)uf`O0go(}4Kg=pdb+3ak@*`r+`z|UcpVO2b&;bFA-vZktrDE&sX>aSF-bz4 zXnj;gNJ0X@dDP9QO#tCQ6U`Qf+u7$(q2etA!wqweiZ*+JYB-&D} zfq03B2BTWK^Ob_DOOGf5jIXz^B*5#cw zO6<~jNB};n24zooFGjTm?{JLsHdryD>McM(D;IFbYZ>J@45n`7cX5eJxLaF^Qj-;Gb)8p!Uhq zO&uOtIv1Dc1DgoQO&=kdklvKZqwTt8j`2>^pQ0rMuAprf9)*d^z95#Uj=&kW>89wI zg>$|@hGF+wPigubDw*#liYu8-pfMJTk&sxH_7Ijp#(~)hKP7E)ry3n%y}uEUW8&l6 zySZUUkT1|7pYgBvh7R5f`r0t5YsjG}AXpCI~6+*^xGY7JmqSWWXcD{$~M5=02 zK3R$EBMKYhhwP@{nAP6Ty?yJ}>P6evmVOk`E}b4T>Mgv6v~{QM!WF%)$g|1Q{g+N< zaZPQ@M)fgxpw!3x&&ut^0rT7Y)nu34r_Muij?G?Mnps)ZM4aVN6tWqCs3Vyh0Z<_1 z84cgulmMmm&FnPv2E;c*$OI@QCbPU?*<=mm&k$fh#~6hIO7_*mQag;B{a*j`q-VHE^|&;1BIweNVp5 zwMvE8tc>MEb5HlwnHPvQ^fv02H;r0pxoYU`1-!h&#uuWidd+}B!_4W+?dDRn_5xb^ z_;AS-G1&)c7TI~1HUmhUvJ8`VN4S!J#(Sx|a?;vsfaC7pbI%o*tRZ7ug@-^u0zeL5 z6q(!}$&pYb!NDRBM9Xsh;{1&RW6Vit{1Z3m6tJ-@-+~@3^b16jDr*-onPx~(IcLZ5 zuhr22EEF^bFb%w=kc3CQ{Wq)JO9qyZxm~U$t&MOAh)_M81I}6mlgy^i#J@H4%$ZL! z>+11*v=hLzvJn&gQnFH7Y6Q?F5Gf8r;FR^b7h}WOq;~n6c9E&vk1Y<&ZnEfEeDfYN zp=F>G!y+St*dvW!WW-k5N%2CJ%Lpz<>1vBB52vW7nf9bRgAH1@)H7(!)qQ@I0$v6S zxx5FRx^-pWA!NrD#?B~+TAt66RR?@z_!IE_9YmH(lg`;JuJo#%8nkuCoWB-6=vMaW zQ{kYz;^MC-e;(3uMNH*{lhZ)NQvvmf`XN3Jn~&yJP*8;HOtUrll+hDUEed!jNYy0g zOUGcIp}#iK;X*pDXW-$0!?j=kri<4`$3jELlJ-KF)+4|NwwPg9JQg>fiVubKX=QE{ zK|;<_@!calng`CfB->mN3FJUR31&h=D5XC<-k>J^0aP>XBt)OwHr5Ni4qG?Ve5TFqNm_mrGZE_ z$W1SpPJn-2@*1Pp-SpLeEzMnSHn05VV>Dvad4Z(+W=cRQwMi-li7#B_4 zA+BJ_`*Z6XEPk=+-b^V@Hz7_7&a+;vey9@POw28az2bP$XTp0!qajbhakHpel*E39 z#|fl-3ThF}l|~B9C+Rj8t#euI&yK4%ZQUvpo9EA;R~USB2)A3I&w=M9VB47UPdVR1 zU9d;~fXRR~>|c)(!~=Ih4G-Isqrbig zG3CLyf`>AsrnmziDN~U2f|_UB4_N#-fYnHh-Ml^$?bo6tu-%9u^YjKTvkEQ5pNl1k z_KqqvDdx-#9Yg?u3@bBP``cb_4%{p<6>RpWt1~z1YqT3R)W(&Y!XXF zDWYU~8)J#M$FZ4c5ZJ_CROn$*QG)D3HQ28HCpGyjfs#6&hGlqQ)|oSB&~-Ft03(fn z%CW!CM?QBsdiU<@$f#(^S~V_;ZlkRktgEdl00|j8U`l%wNsS=Fj zyP{CU^WaqCg$Z)isW@Q6wn4${%YeK7i45QEjx}$1Ei&;*MxQw_xaNb??(0LX>!2a;E%P#o9;XqxSaw&xw|@pH9|eO%nb_^~sYb zVlM#vz(oH|COr!xZaM8&%e9R8dZfR|j-)l)V=Wx8Li3ALFQWY5-{& zWh$fSzB;XN)#Y)>%vl&n4+!IS9cUc}d2^E1{w|)k2t_gD)07$}C>gzQWs{UB0+-zH z3{U}}!0xc?w{Od~PDC=|NkYs;6wrt_ubPuIIrvBATV`Os*h(0h{&H*y--3=zkF_B{ zg!BJ7+f}9|$QBX^{~wRVs#onV^Y2~zE*h!1#@L{wntTud5U`B?Uq$jN&gh!bdjfvV zqK>$^&-_dm`-xua#M-&kDhw{WE?P7O9fd6TC2>(wa>vBwNwnYmMK?ys@xgKOTcBmy zJbmp()o4qukZHLQckjbpqL#O+Q~9J&psXjSW~-pIQxlMlJ0ruFjAN4QkMI#czkOt1 zcjC>IJ3U0Nh&&tmtS^9W%q(*l*wd&KK|LBJY-tLw(T`w*c37ybk39gXy8Qt-^@5u`VuTt#FFV4w z(Y1*2v`h-iUP&P0%q+ZOd}-hczQmYapKw;Yf6#BqG>k9#Yy8fFY2Uill!jB%D{q2q zm5w5fW>t6?aTahXiVOoWCAYbQ#ZCbjIrM!-#N;!~ zM{UAUqyXBl1tAE|)|+*5Okn}qGC4Pn{z|M-#9%cjs2}(R6s_W8uhOm{Z(ce)>249y zb$}ND`CX@>D$F|MG0x5|4~Se^d5+=b^7gVLh+Bv*&LOQ4;Mfz-+|?t=9+VfvEfpwd zF;DVYhO7h-y@%<_#@8%Nach*qpK&}TZC!ehYAM~isDUrZ!ZgyKs^tJCzrgMY?as$m z#$4gxrXeT6qr#ZAqXC={(T|argV?JiEiinOnETN3iqk)MS$c|NA48WbN5-YCdGVf{ zRkkovgudzNs?@FCt&Ga6zfzjX3>(u0Dzef>rd+TO4tNwk)h6oB*l*5PtwgG6Y`=dj z_+aj!4@}O8lQ`A5g1$K&#+9X>)iJNTC+Ye7E&<~!#f1*NKO4q(OiuZFB+IjFGg(;A z8P`U92Ti~{eafn2wfyHbrx!;L_8tbfNKsqz-m|*=Z3cZLL$j7(1;tw;nv1Q0MSQbbq*2r=FPFR z1`3>Q5AgG2w_06=eHAnq(I|Z;M?yEo%KUI#oKV@~J^};)kilNgG0tz|n75O(z;WMH z_DE6O$AZmg2xU=jz zOlUlQ-!;UnX%>MSFCV}|Hciu-D#VkA zQ8zMUz^+{}*Lk+$cTQ>-s(^X4+2jly3IaEEqh@=79t&ypM(}-E!YO9j$hm;7TC8rg zM!&|e!JEQRREp5Ee33{$c`v9YK%a)0>6=X_O3dU08V}?f=K!nzq(yYwRNdUMF)(IYeTalk#?y37?GeI^m9W26yKr-U@U_3g(q$ z(3`5hB)|GToCA8u_N?`ZJ2Z{+L(gFW`b!%a%sXJ0hx@$XF## zi*_PhVQ?wAquutOpZtMn0mj!m%dKaUJ?C~Ve3R@4BA(7>@H%OCiqL`#mLkj+n*yp1 zg#&j=ywT{ygUddzuaH?7smuTdMC5hu6MH9jnJs|wYAx_3Pu3(t36YU(j%VPH^l5J|l$Eu5N7)uJZl9*$jF ziq)myknjoyB5u%cA79w=YMQ5TT}G1-a_iGI>i0Cj6qyy(^oBA- zhp*hbWk5O_7Mce@2z9tBa5Z>lzf~v zl)u(1SN;U|Vr*vSG}igiGRO7~GbrX6QkAi{2Fb6>25h&aGTOd<7=^4%^ueFHJe#tX z#wlQ+f7Wx?^?Y7muLZv$Bkbgpeke_b)%SAlViullWj0_y2C8|$JFJF8 z^aVwt&&`5M^Wc#wz$k(^&eUA#6k>n}8z0;YX{)ViISy=KDdrUPRqNrZWX-22cTM;2=K*+*`k^xgZT}_*I;YE+?CiEjMxMCHF7_PzhZ) zl6Y4CaLIz=gb&i5IP*~zQGcuY zP0kM58qF~uIWh=w?04gA%qYt~Bo<4(;_)lfLo#6vWWn?pdoIczmIOC4x)tNM^zEBB zVn4?awfr{d)@o2{4@OJLl&0vcEMtX(Pas5AxLBj7a%cF^Y zPSgI^^qy8Ydds>GSs1Ivz#VJ6z+Vm4;~4g-%7jjX*UH)JTC;i|n?T9Q?cU;ENGI-A2Qar5;KYf; zPxGThtI3J*U}V_uYmo_z#2eOo6W~B>M|V8+5XXW0_jRcCWXTgOJ$3GM965pJ*;BJ6 z_Oe;NX-%IEW9I&Xkr(*X2pA~A2Wau7CZusqdfy;;pH9?mf^-{{>ZI2 zP#VQ$c}?xo{K{K;0`+qXld>jD(FA6jce`rs^YZr8twmd?-pw~)&A z0tgLKS68pANUoQ0MU*0f9iZx`xtOwlvtnsZwM|?9c5$cc*jdEUo{#@o;OTmF7^g6G z5xX*yDNgcZO8Ol`%p zrsMp~tgJ|#>`O^W62VZ_%%d=o15A$T&A?RNtuenl_->pM^TeiyRujV&KmG31P5dfE zP6dKPZ@Q?!dZdi7;Uz@SEvTMJHsi_zeWnx3QaP768WqwkvEI+_#F*3!+ad0GG(P}e zt`?OWEYoqeF4aK{m-`TJg=8G7I0mTPDMr9P`SFpJ*bY zK!81Z#McBWc$H?*_P8)jn4hrQEMG~i;KXv1o>LsfuACTCSsnLR3bdRTeJ)wo74N^Y zTtvTi^bAsL%TO2HCNWXQMmX99lTKx;M`piGp_UN4Yks$RBrm4GEkgE&h%1M+P*Uf4A2=*JIXDef0r9O|=5!uMLh1F9o z^_;a}f#?v>D`6+Cf+vhqw}_)E?d;Mp#-WASxp(gv<_m=3WTe(A-U;9?c@|=MUQ=Ll zvSIL1l|2ikFr;p0w_4SDUQJDvy}}fBE|Jf-hV9tMHR^6}*`J+E zY*{Sp14tmh0xZ(7j5V0hgrb!K%5eE}anrc{4i^Bd*jJfJJzJ1GZR*r~4EmYFkQz`- zhYvX(aOy_QDds3r-*K{gO+PQ|>h2KuHGf&4g^WO3ece!8XWQZBjeaMJp4J^=9~?-I z1kM24bkA#h8$`D*@{6K~1=M=Q$4Em~M1^<5T!~U#46eo3OO7e)t_T!1L$n&@U()HR zVXf7uX(vX3VHd#vspATjI->>P9MML%!SmRIyY~q z=9(jH~0xV*D# zT}7mjD3@jD0sRF)g4k($U25`yD2ba!AEKFTxj`-BI%m%3Bi%b}n&e;>;uMPZ;3_a3 z=qpQ{$J}djo;H*g>L3Y^zKsS<9MO1N^+ii@PTfLgV=!qq5jcp%xpaGG_ntikHisH) zmb5$OcbvUYKXEZL9zD|a_xHzn+8&w%IhoX}uq!RkR~-7u8d8-07Bb(_Xuoe? zH=kgAETFoG+D{S?mAnIML|~C_f_o&QIRq9IXqBnGv7eRv*2Jw>qwxD?K6XU2Jl&Y` zOeWZIKM`#JY{C}cMzU%LYIR#cslpkNhuqd>XY8Wj!y>E!K7r2At20<%A4v;APhMtG z!zYp841f0#kF4>&h#`a(0U!~?kaCPYxCi;J;0cHBT<=O%+S5UuZAO+gs!jYy`CP8R zm5~AhE0eDe`@jxy3W@ilMvqp`c^A5z-cQB_InpL8Cp^?I?w&iQ;soe3=mM!uc5WdF zyiRX(-m|15V5hXCR9MK>R3Ns;f*!8%0JdD=Q;H7^3V(i_qF=|D)7jmI(!o^z>sno1@x$-AfLnlq4PWpvE<7#%_)Pl{5T5&h%r4}wW)3#Hajkia6=GckkZqaWBE^!y>f>kItYcK_x$;zOI&Th$TH%P2k zpbJn|6reMkg#ibX0U} zE_LGAi@y~OBV7sO0o%M|^7Tvp^_KW~g;lS$NzOWA-R&yqXc!w}06hz@cXhlMd-gm? zysk8yBzl=FVeB65Kjwl$fqM*1`1)ZFheHr#=KW9<1m`tbpZu0#Clhn?wuG9*W=Au; zziqyfa4pz2WrL(Ba4wzp?L&ZHM9Q=^vRGufQrikY_WqyptIj)0&tYyaBb+iS1aFC| zb#`E@yG?)iL0SZYy39B6aVeToI4m+ppd=gtb9CBSL0hL&PynL}V(4{$rZAqQMMWjc zGTFu!=6SCYJC{lgn-Jj zal`7T_LRMJ;WCX6>`MQanH!X9^5e$wswkgtbwVU0NEUD-@z;$;i>db3KKrN(2<#p& ze9(x{;vW!+DB27<)1fmy{tYsHLML{KZ<6@SQ@*OP<;ICDT@>ZZfge>RSCHKU00f9xV6-M+rJ7+ zRgI6Nyq&|PR1!%rEf~1AtT94+g6^p7GynoQ!YDE=IXE4)cu!{%w8#4CpU%5vix znR(S76KWiMK-N~0bYmR4h%FffvjWpi?C@VI=jvGcIkx|m3fxH(H*Yp_ z9$KG&>%$&N$Bm2?BwAn%6m3R8L=vANVJYpp)gS)6Pp02N^#3>MYI4kfm9Ew|NLNSx z8|msN+6>5i9M6o4Q%0U3nvmrZe{oN(b&u|1aePb-Bkg z-IrF;k{#8_j>%;ief${nAk`?k%(!62oe}l}fZY|wcFL4Cj0u^5g<3k_@s%1Ahz{|i z2Z@?8OIAgZi4M%Zx`Dbnft$x9kOn*j>?rsuZlLMBwFC{;Q$7%iKQ%(ve(C1xs_ zQ7ozrEG(uuH(mfkOwDubj_aWUBS0i5trT&>WGxQKkiszJfvMRp5(T+ZcJ46B#K?+} zOx$e2aY#Nb;A1)VQdzcZC$e&Wu=pmn9k^`PgqdqfoBjW-bS;^7F~{!xkoCg?(RL7m zG7u^O?^&`F_nhBFgysYj`0%9qx?$`5d-m%W4yc}2zR-)XD{OemkQuC?KoXM$?KF@% zY|h6K${QnNW7*8f2SeY`^Y<}YIcvcY5|G6RX#%4oI#AEiJ6wGEl0~4b zAWOlIqw&VT`Qy+o2$bTv{?FG4Ymdh~{XYw9R~bK0EgD*SxEZ9LCRN45lQTu%{{&Ww zGEFvh!;4-k*|g@>_OD-f{tCL934vJ;wuXOI9$H_soPIOjDZT|%^I)&i0HS59ftFlA zFa-)eu*a=QU;iroxC)3$s6lSd(&KA-)>cp!Ii8s}4p5hK3n9{*jV&>GpMbh$Qx9UL ziL;Ja=D&1xbIYJjB%(BdSu-{<3F1__%$}{3wEyP3#fxw9zZFJ3BsqwwATCYPNh|y> z3_nxqE{>{H6jEr4E{o<{m^{7{x9KpE2uB+|uQM0-e?Cc1#4((WJW-eo*BZlQYH#7Yer6JbDI zd=l1mozFPsdPJ7=g`IgYG^OG@zj*Ot@wA~gDdcGj8b+l7hu+hEi9gSZ-#CuDY3tjH z6(QZuI=TFFM&CEPZt>fjo=+SnE{yqFUCpQXPVxB$1|Fc<2XWA)0Wv-%CnsWXYE|*+?)TmMz15H8@Xc-zFRL&SR zcRxG{afcz_o#9)v>wC>_UG8Cl;W=^)CMu%{P(t!@D46Cnp{S*oAgF7;`)eYvmQ)^6 z46|j#c6gqtJ42ER3V{q_{emY6hkQ4GeS4W4f^gc6B99#Y`S_^NVvps^ZC6>TNZUov zIe!1(#z`Fm_A&HG@!Q-e?&E)}`o-}ru*uu|noRd0 zE#qfK5YIn8af@zsVc?d3qxW6fIS!hRNTd-taJkxsTj+z(gnmn?h&(a&$@A8@Ufm)lcYpqZjKeSCn)_@&{Q=lss zn0+~%IZ!Bj8iT?a=hN2wtamQbbfzpxl{^3vipKT;zq1Ua@*gBjnJ?DtP_eBzg)G$; zQ5*4%hO7}abDy6-H%1;(DMB2Rh^Imja_^>Dym)YQ!dgP;UHGb)S?&803n+}WfBbPQ z34l{PkD#Gf({7!oVMP4bA;)s`&>9b-zLgm+q&c*!RTudw`z%-Q0VX3*t&fO^NZK2^ z@mre10K_*gyZw5cwCH&lT@b+{;1M#N>;BayYlH56#FbS(0jG~rGhIJ>WZbC{&S-Z) zVN%}qeDH@;eA&Z_?6)^L;f1!zQHAW&R@*qauVS55J_k0gPz*$ zEuH;;>fNRDZU8mBNPH8UAvLdCFtu)ydB~s`^SCy^7?iZThf`4SB`$P5_zWMna@^(^ zU%+)9y!xxya0_n6jBoB}=hkLHJ}wL4j^Gxg{3a2Q?zYl2m0s9y*F6V68tks9d5aZ3e_kyy-s7a!kfJg>?6VSfHesK(iwA!1wJl1O|R zSD3ydvQy0%Q8EhNcxlz-x|@_SVrhO~8TRH3Tn~9Vs*gU~ z`lwl1AgjF5&tROvgFrqnF9NFypG6hnw8p1c@W>yCaVPL-EC8_Teig0?&@`6F&^~J( zj~es6U#rxJAMgbgo1o$wH*YRLPfEKkUc7=eQX|*hRV1KY+FF5mgoVXkdZ^%apSRj@ zL#Qpg|28)mcuP=uq{L!vO`u%bU*k_G(=2Hu0r)^1Ra;C^y(L4eMlOM+p2+66V8bjz zNy?_bVF#s`5#oZ@640$RlZ8uiFW&+kV~ER55qp2?RXcalFN+HA!0;gDiZfssfM9MY zQ$%7yuZiqfQz22BHb*=I#r&6yA#-^*u3x`Gvhy1uRVSVlxXfe;oX-F-N93j0it;P@ zetF^s;3?Z;@abrp!j6`s)D8z$Sfy>)8tL>C;}0T_=V5Mx-9gXKsKWNQR!9ouo1okH z?nF{kw6yj?J-r~afT$Pf)TG`A_!K?`?E}b-7%hlut8`vKEJf(jS~dOss_krQpIg<= zM3hKM2 zp;P3#H$^jx1|pGX$}-;q;+v!b&J;~l&y)M{_8&vf#%F86Bni)F!?w(!)aL-9G9V{K zEr1LPf^{1|On1Dc@xs>N2I`|!`kIN7DZRcMWRvuDKb4LWAF=@Kj(bj+80 zRuG1+@{t*nlGP-IqATVamwj?B9_b8mfIDSav}SBg|B%nqlPQt;qzc)RO5`U93@5)M zWky0a+4(c%(a)-1b#yWD;*Y67=?o9tsn?reYB~O1r9F=dYVQcYoM5v1eUGtZfW8j0 za4wLN2p+i~4S_{@!e4tv?eY4ZW)cuxmd~IMn?qtP>-7{uPU<>jd94OI8~mvrXL*%* z4;6#9Q}1sa=-`XCz%FiIG}#0-OVbo4Rm7hBnJ#UDaaE<5CK3VqkpSo|mRE_yQKY>x zAX2&;4s@3#a!Ld;)-pAQ2m!nn4E)+$3+AY$9tMVyhzO}i5*Ts26II%F-2sZUf|k}= zIqgrcCEcarau5JU3ob65G3SJA&OQ)mkJ`7bKB6eOP7oC}8WFy>`R(bIM+8IVwYDK+ zL+v(d(yU3>h|!3KsNfrM)#g%cl)WxCRlk>##;t0@3PU{m83&x6WHWytxv)98(EsiK zM{To*dfdP2nnTrHh6TTJw6_8X?l|MZZ`&*yMmx(1n50|x+)p`eWnM@4@5(R9ZS%*(p~a>-nU6(Uu^WH2h+pZ(OYWo5Bna*W@A z9mNq|GqZoVcZm*uGvFZ~4&Xr-_y@RDjDg557|^t0(lsF=;V5sDsxubsJ>~77ILG)V zMte85Ik1~5qm9{oEy}i?Cb0_iDAL6vb%!$+_iHq-{qXigX-zW914Lr*hSeMPGO`4= zSZ<|)=_>B;Hz?J1S+2g2wD2bZAg3~Y48#xk&U6O^a~~FK>mwHeq9k#N!xtWIG0+$< zrpAzSo{5_C7#9E zUHLu5yN>FJ@YowWWwggVOXARuYK|RWf%62%*kwTfrVV4Ew8%?6{6I+cO`X)GF~Buv zG#%0#W=LiI36BcaNj?h%aMua3>)v$FUPg@zzby-OQEW=_Pkz8wZq}kjAuJ3;^eYM$ z@ufvsBwq0Ymh4NaPVmxg*(g8RNCf>OM-(d{j(c!PRGm$F44^YWks&xJ7#tc*ODN+Q zYUBDho>_GKh<+7P+Yy55pZuxepT&=m-Fv*;@2hv2TiAp=D`2pzHym%7W;!52Tl|42 zSrtn=NB5fc*Jf-uCm0zn>dn2=&tqzvs+nh4d0_-Hm|%lZ#D4d-tF*muW> z5O!H89eF3xXfX7Hbli&EBx9fa%@`ss;uQ_VXMIv?8Vl7xS*RRCY-D_i=TZGI_^|>r zu-QO-gZ*mS1n?315XHP7{D!V(f{B@vgG1P0^9S&sJj)v@TZ%=;OR@tiP@jcp>xZ^| z8};jVrn%4M)anD4R@sQS;hDq@p3o{rGZe+wGCCrb=UH>1uh5GyOx5kTh{4v&SG@lx z0*#cMHcAzqXT$E`;0(kcG8YepO0}F$sy<3JtR4Ml=?S#S*@R++Am{WV_aW5ru`F2S z%Xr9-1D7cPri8hoY*fnGbJqCyuI}@VS@i-*&y}(q zQAi`g0mi;zCVy@+GP>o7s!u{CXRXPx%|DzpiHGpn%CAIa(lhrH{o?%es5|UNQ=UgB$QTP3Uk<{G!E60wxLW zbt{UXSWO{aq%HpXpC!=SOYEYj=x|0buYnqC-=|M=ehYQK(pGR|lY1rZ{BQDv!Z( zrV7Kirs7{g-zqPkZ$On}MO%^SIbHT4!el8q8OBqm4%640D?@08+^jNLwpy!Jt-}2D zj(kZWgDApyc!Af4G}y6wx80;kElEr5fk==a;W*LI56p=+?dI#(yFpKv6lPfvy(e5; ztP4(P?e*ctm6ZGUg<(S5QpaOpUh>VGf(JUXvE{(D)lVpFi%LtGysD*u>X69+Li&ae z$^m8Vncigc041WJOPpsE3m;F6E#Om4M6^Lqrjo?(+AZc1IWm>A_Zd}=4=%pCQ|MUuMGoxt!@u8!Bf8X z=+PWz0N__B#KM(J2YdgegP0h&L#*krj-$pCwFLL-F&aDbG^G*YfE$!~ub_Hmwv7

^o>L9{L`Lp7aACRrlFonR7C#mU6g6>lH}1XT5s4Co1H z5%r3PGEVa-ux^Ldg^gb`sL2#tG74eN)ZK_-D(Z9sdPYWdJkGp+1u5jg1S5III5;4- zy1T#}1Q$S@2DF;rI`e74b`#*_zQy)V2F%4->Q;;;_o1X55^ zNvJcp+*h}XjCywdi!BJG@fRQa+t%i{&CzHht;)iijbNG90VT*-mx5HoD26!XiWCUI zR9ORqEtoD5DKA1xxPi~Aef?Fvf}4M8d0a%NF^HA)`Bo>2RCx*FXU9^5?OP+5RRAZ5 zCebiWMBE%aZQ22k_H%WPJSyN3bfO%gjOG)V6=D&MY0D$at!rP@bp`z5eONoSc=P=E z`NuQXZr$_kAseTYslC{0*G}3n=t9P>vQMlHQt$W%I0-&ly=tn(ve+H3C`1ti9Y#Du z)@_DTwQU|B$IbWNs&v`fCCox}<0DQy5Hqk2M%ISp~4L>Iw!1nlmgcV%-S z6hoJcx;-98Y@0Ye>^U9jT_iIYxV|GKCW8|ZGKu|Zob_6F%W-mGB& zTYi{o?On`C+0a7zzX+NqwqJ9u6B4df|CmqMKⅆ|KY47MU8*^$RXRxrv8B})4pY( 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

Q<*) zzi1lz58S2POuUhDV&rsv6RJ1fa-t#LQQbv!-f-v5Bw*+G@#D%b=m!HSUzS3&D5P=b z^HB1He5`D^g3kl5a~niK={T1kg~(A{38~eiGxlOt^gs(CO{{>>T`D`*v<8ZjoF2^9 z&j({U37oS02WAW6gbA$m9st28K^6M?sr*Rb4339&d>gT3IbnIo?LUO0!ZS~iT1XN;P@Ik{t8_c}Q3KBEA*ej~fNS+W0 zBraSTlx6DNKTqcOpr*iI-2g!cERx^LS$_lTky9F^L4m1Pz$|dm<}NFfOqu_Chx1v| zKE;8MfLSn+lryryxbJVB zSD(~U2BGkjhmO?n`XZaJ#LWS_Xc|!oYZ>h zQuDydL!uk0dS_W{KVfQ<4K_a0U?mRl4N}_HYI86!TuE?zvz$uc1qu~CKdyjs& z>h7}PocC?saeSa~7!282bhFvaiSwVHlHd;7N^z-oUEaER_d%brm4l^vO}c7Y6Ghb_ z`UBXtz}m?eIp5OpN)SHB6Ilzbf0}wpf}q&0@7M{bH68=@4XFI{oMmptT zZd0pQ&v@NNn7O$Zp1<=xMr(5E>Q$8)E-rGx7Zw%eaH_Ke405?k8KIIzd_-_$aof>c ze}rBrL}X5H)eQ~|O4SBD_po<`3Duc|fMOP$`WS6DKT!wtt!Jj!AX;lCfXKKUe!K

9VcxsY{4RZC}~OUWst1+Szl&xJeXkCUGOZh4 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 xKmDi8|DVJE+viYLHQKA1U(McXQ40QYu Date: Sun, 23 Aug 2026 02:41:53 +0000 Subject: [PATCH 08/28] feat: add strict distributed Triton FFN for ROCm --- benchmarks/benchmark_rocm_ffn.py | 399 +++++++++++++++--- .../kernels/ops/triton/activation/swiglu.py | 48 ++- rl_engine/kernels/ops/triton/ffn/__init__.py | 6 + rl_engine/kernels/ops/triton/ffn/ffn.py | 200 +++++++++ .../kernels/ops/triton/matmul/det_gemm.py | 313 +++++++++++++- tests/distributed/test_qwen_ffn_topology.py | 44 +- tests/test_det_gemm.py | 75 ++-- tests/test_qwen_ffn.py | 65 +++ tests/test_swiglu.py | 28 ++ 9 files changed, 1062 insertions(+), 116 deletions(-) create mode 100644 rl_engine/kernels/ops/triton/ffn/__init__.py create mode 100644 rl_engine/kernels/ops/triton/ffn/ffn.py diff --git a/benchmarks/benchmark_rocm_ffn.py b/benchmarks/benchmark_rocm_ffn.py index 8cc3f895..8216d736 100644 --- a/benchmarks/benchmark_rocm_ffn.py +++ b/benchmarks/benchmark_rocm_ffn.py @@ -41,6 +41,12 @@ from rl_engine.kernels.ops.base import _C, _EXT_AVAILABLE from rl_engine.kernels.ops.cuda.matmul import deterministic_gemm from rl_engine.kernels.ops.pytorch.ffn import qwen3_ffn +from rl_engine.kernels.ops.triton.activation.swiglu import ( + _launch_swiglu_bwd, + _launch_swiglu_fwd, +) +from rl_engine.kernels.ops.triton.ffn import qwen3_ffn_triton +from rl_engine.kernels.ops.triton.matmul import deterministic_gemm_triton _MIB = 1024 * 1024 _REQUIRED_SYMBOLS = ( @@ -184,6 +190,7 @@ def _single_gpu_benchmarks( right = _randn((k_size, n_size), seed=1001 + shape_index * 2, device=device) native_output = torch.matmul(left, right) deterministic_output = deterministic_gemm(left, right) + triton_output = deterministic_gemm_triton(left, right) fp32_reference = left.float() @ right.float() torch.cuda.synchronize() @@ -193,8 +200,14 @@ def _single_gpu_benchmarks( deterministic_samples = _gpu_event_samples( lambda: deterministic_gemm(left, right), warmup=warmup, samples=samples ) + triton_samples = _gpu_event_samples( + lambda: deterministic_gemm_triton(left, right), + warmup=warmup, + samples=samples, + ) native_timing = _summary_ms(native_samples) deterministic_timing = _summary_ms(deterministic_samples) + triton_timing = _summary_ms(triton_samples) results["gemm"].append( { "name": name, @@ -204,9 +217,19 @@ def _single_gpu_benchmarks( "dtype": "bfloat16", "native": native_timing, "deterministic": deterministic_timing, + "triton": triton_timing, "overhead_ratio": ( deterministic_timing["median_ms"] / native_timing["median_ms"] ), + "triton_overhead_ratio": ( + triton_timing["median_ms"] / native_timing["median_ms"] + ), + "triton_speedup_vs_hip": ( + deterministic_timing["median_ms"] / triton_timing["median_ms"] + ), + "triton_vs_hip_mismatch_count": int( + (triton_output != deterministic_output).sum().item() + ), "deterministic_vs_native": _accuracy( deterministic_output, native_output ), @@ -214,9 +237,17 @@ def _single_gpu_benchmarks( "deterministic_vs_fp32": _accuracy( deterministic_output, fp32_reference ), + "triton_vs_fp32": _accuracy(triton_output, fp32_reference), } ) - del left, right, native_output, deterministic_output, fp32_reference + del ( + left, + right, + native_output, + deterministic_output, + triton_output, + fp32_reference, + ) torch.cuda.empty_cache() for case_index, tokens in enumerate((1, 8, 32, 128)): @@ -228,6 +259,7 @@ def _single_gpu_benchmarks( native_forward = F.silu(gate) * up deterministic_forward = _C.swiglu_forward(gate, up) + triton_forward = _launch_swiglu_fwd(gate, up) def native_backward() -> tuple[torch.Tensor, torch.Tensor]: sigmoid = torch.sigmoid(gate) @@ -239,17 +271,20 @@ def native_backward() -> tuple[torch.Tensor, torch.Tensor]: deterministic_grad_gate, deterministic_grad_up = _C.swiglu_backward( grad_output, gate, up ) + triton_grad_gate, triton_grad_up = _launch_swiglu_bwd(grad_output, gate, up) - for direction, native_function, deterministic_function in ( + for direction, native_function, deterministic_function, triton_function in ( ( "forward", lambda: F.silu(gate) * up, lambda: _C.swiglu_forward(gate, up), + lambda: _launch_swiglu_fwd(gate, up), ), ( "backward", native_backward, lambda: _C.swiglu_backward(grad_output, gate, up), + lambda: _launch_swiglu_bwd(grad_output, gate, up), ), ): native_timing = _summary_ms( @@ -262,8 +297,16 @@ def native_backward() -> tuple[torch.Tensor, torch.Tensor]: deterministic_function, warmup=warmup, samples=samples ) ) + triton_timing = _summary_ms( + _gpu_event_samples( + triton_function, warmup=warmup, samples=samples + ) + ) if direction == "forward": accuracy = _accuracy(deterministic_forward, native_forward) + triton_mismatch_count = int( + (triton_forward != deterministic_forward).sum().item() + ) else: accuracy = { "max_abs": max( @@ -275,6 +318,10 @@ def native_backward() -> tuple[torch.Tensor, torch.Tensor]: _relative_l2(deterministic_grad_up, native_grad_up), ), } + triton_mismatch_count = int( + (triton_grad_gate != deterministic_grad_gate).sum().item() + + (triton_grad_up != deterministic_grad_up).sum().item() + ) results["swiglu"].append( { "name": f"swiglu_{direction}_m{tokens}", @@ -284,9 +331,17 @@ def native_backward() -> tuple[torch.Tensor, torch.Tensor]: "dtype": "bfloat16", "native": native_timing, "deterministic": deterministic_timing, + "triton": triton_timing, "overhead_ratio": ( deterministic_timing["median_ms"] / native_timing["median_ms"] ), + "triton_overhead_ratio": ( + triton_timing["median_ms"] / native_timing["median_ms"] + ), + "triton_speedup_vs_hip": ( + deterministic_timing["median_ms"] / triton_timing["median_ms"] + ), + "triton_vs_hip_mismatch_count": triton_mismatch_count, "deterministic_vs_native": accuracy, } ) @@ -307,6 +362,9 @@ def native_backward() -> tuple[torch.Tensor, torch.Tensor]: deterministic_output = qwen3_ffn( hidden, gate_weight, up_weight, down_weight ) + triton_output = qwen3_ffn_triton( + hidden, gate_weight, up_weight, down_weight + ) native_timing = _summary_ms( _gpu_event_samples( @@ -322,6 +380,15 @@ def native_backward() -> tuple[torch.Tensor, torch.Tensor]: samples=samples, ) ) + triton_timing = _summary_ms( + _gpu_event_samples( + lambda: qwen3_ffn_triton( + hidden, gate_weight, up_weight, down_weight + ), + warmup=warmup, + samples=samples, + ) + ) results["ffn"].append( { "name": f"ffn_forward_m{tokens}", @@ -332,9 +399,19 @@ def native_backward() -> tuple[torch.Tensor, torch.Tensor]: "dtype": "bfloat16", "native": native_timing, "deterministic": deterministic_timing, + "triton": triton_timing, "overhead_ratio": ( deterministic_timing["median_ms"] / native_timing["median_ms"] ), + "triton_overhead_ratio": ( + triton_timing["median_ms"] / native_timing["median_ms"] + ), + "triton_speedup_vs_hip": ( + deterministic_timing["median_ms"] / triton_timing["median_ms"] + ), + "triton_vs_hip_mismatch_count": int( + (triton_output != deterministic_output).sum().item() + ), "deterministic_vs_native": _accuracy( deterministic_output, native_output ), @@ -350,6 +427,10 @@ def native_backward() -> tuple[torch.Tensor, torch.Tensor]: value.detach().clone().requires_grad_(True) for value in (hidden, gate_weight, up_weight, down_weight) ] + triton_inputs = [ + value.detach().clone().requires_grad_(True) + for value in (hidden, gate_weight, up_weight, down_weight) + ] def native_training_step() -> torch.Tensor: for value in native_inputs: @@ -365,12 +446,21 @@ def deterministic_training_step() -> torch.Tensor: output.backward(grad_output) return output + def triton_training_step() -> torch.Tensor: + for value in triton_inputs: + value.grad = None + output = qwen3_ffn_triton(*triton_inputs) + output.backward(grad_output) + return output + native_train_output = native_training_step().detach().clone() native_grads = [value.grad.detach().clone() for value in native_inputs] deterministic_train_output = deterministic_training_step().detach().clone() deterministic_grads = [ value.grad.detach().clone() for value in deterministic_inputs ] + triton_train_output = triton_training_step().detach().clone() + triton_grads = [value.grad.detach().clone() for value in triton_inputs] train_infer_bitwise = torch.equal( deterministic_output, deterministic_train_output ) @@ -389,6 +479,13 @@ def deterministic_training_step() -> torch.Tensor: samples=training_samples, ) ) + triton_train_timing = _summary_ms( + _gpu_event_samples( + triton_training_step, + warmup=max(1, warmup // 2), + samples=training_samples, + ) + ) results["ffn"].append( { "name": f"ffn_train_fwd_bwd_m{tokens}", @@ -399,10 +496,28 @@ def deterministic_training_step() -> torch.Tensor: "dtype": "bfloat16", "native": native_train_timing, "deterministic": deterministic_train_timing, + "triton": triton_train_timing, "overhead_ratio": ( deterministic_train_timing["median_ms"] / native_train_timing["median_ms"] ), + "triton_overhead_ratio": ( + triton_train_timing["median_ms"] + / native_train_timing["median_ms"] + ), + "triton_speedup_vs_hip": ( + deterministic_train_timing["median_ms"] + / triton_train_timing["median_ms"] + ), + "triton_vs_hip_mismatch_count": int( + (triton_train_output != deterministic_train_output).sum().item() + + sum( + (triton_grad != deterministic_grad).sum().item() + for triton_grad, deterministic_grad in zip( + triton_grads, deterministic_grads, strict=True + ) + ) + ), "deterministic_vs_native": _accuracy( deterministic_train_output, native_train_output ), @@ -420,8 +535,10 @@ def deterministic_training_step() -> torch.Tensor: grad_output, native_inputs, deterministic_inputs, + triton_inputs, native_grads, deterministic_grads, + triton_grads, ) torch.cuda.empty_cache() @@ -952,11 +1069,19 @@ def _distributed_ffn_benchmark( cp_group=cp_group, sequence_parallel=sequence_parallel, ) + triton_forward = lambda: qwen3_ffn_triton( + *shard, + tp_group=tp_group, + cp_group=cp_group, + sequence_parallel=sequence_parallel, + ) with torch.no_grad(): native_output = native_forward() deterministic_output = deterministic_forward() deterministic_repeat = deterministic_forward() + triton_output = triton_forward() + triton_repeat = triton_forward() torch.cuda.synchronize() native_forward_timings = _distributed_wall_samples( @@ -971,17 +1096,29 @@ def _distributed_ffn_benchmark( warmup=warmup, samples=samples, ) + triton_forward_timings = _distributed_wall_samples( + triton_forward, + group=dist.group.WORLD, + warmup=warmup, + samples=samples, + ) native_forward_summary = _slowest_rank_summary( native_forward_timings, dist.group.WORLD ) deterministic_forward_summary = _slowest_rank_summary( deterministic_forward_timings, dist.group.WORLD ) + triton_forward_summary = _slowest_rank_summary( + triton_forward_timings, dist.group.WORLD + ) native_inputs = [value.detach().clone().requires_grad_(True) for value in shard] deterministic_inputs = [ value.detach().clone().requires_grad_(True) for value in shard ] + triton_inputs = [ + value.detach().clone().requires_grad_(True) for value in shard + ] def native_training_step() -> torch.Tensor: for value in native_inputs: @@ -1007,12 +1144,26 @@ def deterministic_training_step() -> torch.Tensor: output.backward(local_grad_output) return output + def triton_training_step() -> torch.Tensor: + for value in triton_inputs: + value.grad = None + output = qwen3_ffn_triton( + *triton_inputs, + tp_group=tp_group, + cp_group=cp_group, + sequence_parallel=sequence_parallel, + ) + output.backward(local_grad_output) + return output + native_train_output = native_training_step().detach().clone() native_grads = [value.grad.detach().clone() for value in native_inputs] deterministic_train_output = deterministic_training_step().detach().clone() deterministic_grads = [ value.grad.detach().clone() for value in deterministic_inputs ] + triton_train_output = triton_training_step().detach().clone() + triton_grads = [value.grad.detach().clone() for value in triton_inputs] torch.cuda.synchronize() native_train_timings = _distributed_wall_samples( @@ -1027,12 +1178,21 @@ def deterministic_training_step() -> torch.Tensor: warmup=max(1, warmup // 2), samples=training_samples, ) + triton_train_timings = _distributed_wall_samples( + triton_training_step, + group=dist.group.WORLD, + warmup=max(1, warmup // 2), + samples=training_samples, + ) native_train_summary = _slowest_rank_summary( native_train_timings, dist.group.WORLD ) deterministic_train_summary = _slowest_rank_summary( deterministic_train_timings, dist.group.WORLD ) + triton_train_summary = _slowest_rank_summary( + triton_train_timings, dist.group.WORLD + ) local_accuracy = { "output_relative_l2": _relative_l2( @@ -1053,6 +1213,22 @@ def deterministic_training_step() -> torch.Tensor: "repeat_bitwise": torch.equal( deterministic_output, deterministic_repeat ), + "triton_forward_mismatch_count": int( + (triton_output != deterministic_output).sum().item() + ), + "triton_train_mismatch_count": int( + (triton_train_output != deterministic_train_output).sum().item() + + sum( + (triton_grad != deterministic_grad).sum().item() + for triton_grad, deterministic_grad in zip( + triton_grads, deterministic_grads, strict=True + ) + ) + ), + "triton_train_infer_bitwise": torch.equal( + triton_output, triton_train_output + ), + "triton_repeat_bitwise": torch.equal(triton_output, triton_repeat), } gathered_accuracy: list[dict[str, Any] | None] = [None] * world_size dist.all_gather_object( @@ -1074,10 +1250,23 @@ def deterministic_training_step() -> torch.Tensor: "intermediate": intermediate_size, "native": native_forward_summary, "deterministic": deterministic_forward_summary, + "triton": triton_forward_summary, "overhead_ratio": ( deterministic_forward_summary["median_ms"] / native_forward_summary["median_ms"] ), + "triton_overhead_ratio": ( + triton_forward_summary["median_ms"] + / native_forward_summary["median_ms"] + ), + "triton_speedup_vs_hip": ( + deterministic_forward_summary["median_ms"] + / triton_forward_summary["median_ms"] + ), + "triton_vs_hip_mismatch_count": sum( + value["triton_forward_mismatch_count"] + for value in valid_accuracy + ), "output_relative_l2": max( value["output_relative_l2"] for value in valid_accuracy ), @@ -1090,6 +1279,14 @@ def deterministic_training_step() -> torch.Tensor: "repeat_bitwise": all( value["repeat_bitwise"] for value in valid_accuracy ), + "triton_train_infer_bitwise": all( + value["triton_train_infer_bitwise"] + for value in valid_accuracy + ), + "triton_repeat_bitwise": all( + value["triton_repeat_bitwise"] + for value in valid_accuracy + ), }, { "name": name, @@ -1103,10 +1300,23 @@ def deterministic_training_step() -> torch.Tensor: "intermediate": intermediate_size, "native": native_train_summary, "deterministic": deterministic_train_summary, + "triton": triton_train_summary, "overhead_ratio": ( deterministic_train_summary["median_ms"] / native_train_summary["median_ms"] ), + "triton_overhead_ratio": ( + triton_train_summary["median_ms"] + / native_train_summary["median_ms"] + ), + "triton_speedup_vs_hip": ( + deterministic_train_summary["median_ms"] + / triton_train_summary["median_ms"] + ), + "triton_vs_hip_mismatch_count": sum( + value["triton_train_mismatch_count"] + for value in valid_accuracy + ), "output_relative_l2": max( _relative_l2( deterministic_train_output, native_train_output @@ -1123,6 +1333,14 @@ def deterministic_training_step() -> torch.Tensor: "repeat_bitwise": all( value["repeat_bitwise"] for value in valid_accuracy ), + "triton_train_infer_bitwise": all( + value["triton_train_infer_bitwise"] + for value in valid_accuracy + ), + "triton_repeat_bitwise": all( + value["triton_repeat_bitwise"] + for value in valid_accuracy + ), }, ) ) @@ -1132,8 +1350,10 @@ def deterministic_training_step() -> torch.Tensor: local_grad_output, native_inputs, deterministic_inputs, + triton_inputs, native_grads, deterministic_grads, + triton_grads, ) torch.cuda.empty_cache() dist.barrier(group=dist.group.WORLD) @@ -1275,8 +1495,12 @@ def _write_report(payload: dict[str, Any], output_directory: Path) -> None: distributed_rows = payload["distributed_ffn"] methodology = payload["methodology"] - def ratio_range(rows: list[dict[str, Any]], digits: int = 1) -> str: - ratios = [row["overhead_ratio"] for row in rows] + def ratio_range( + rows: list[dict[str, Any]], + key: str = "overhead_ratio", + digits: int = 1, + ) -> str: + ratios = [row[key] for row in rows] return f"{min(ratios):.{digits}f}-{max(ratios):.{digits}f}x" forward_rows = [row for row in distributed_rows if row["direction"] == "forward"] @@ -1306,6 +1530,16 @@ def ratio_range(rows: list[dict[str, Any]], digits: int = 1) -> str: row["train_infer_bitwise"] and row["repeat_bitwise"] for row in distributed_rows ) + triton_consistency_rows = all( + row["triton_train_infer_bitwise"] + and row["triton_repeat_bitwise"] + and row["triton_vs_hip_mismatch_count"] == 0 + for row in distributed_rows + ) + all_triton_rows = gemm_rows + swiglu_rows + ffn_rows + distributed_rows + total_triton_mismatches = sum( + row["triton_vs_hip_mismatch_count"] for row in all_triton_rows + ) lines = [ "# PR #325 ROCm deterministic FFN performance analysis", @@ -1328,8 +1562,11 @@ def ratio_range(rows: list[dict[str, Any]], digits: int = 1) -> str: "- BF16 operator inputs; FFN dimensions are H=4096 and I=12288.", "- Native GEMM is `torch.matmul`; native communication calls PyTorch's " "ProcessGroupNCCL directly, which uses RCCL on ROCm.", - "- The native distributed FFN uses the same weights, TP/CP/SP sharding, " - "and collective schedule as the deterministic path.", + "- Three compute paths are measured: native ROCm, the strict HIP " + "correctness kernels, and the new strict Triton kernels. HIP and Triton " + "share the same deterministic RCCL collective implementation.", + "- All distributed paths use the same weights, TP/CP/SP sharding, and " + "collective schedule.", f"- Single-GPU timing: {methodology['single_gpu_timing']}; distributed " f"timing: {methodology['distributed_timing']}.", f"- {methodology['warmup']} warmups, {methodology['samples']} measured " @@ -1351,20 +1588,27 @@ def ratio_range(rows: list[dict[str, Any]], digits: int = 1) -> str: "", "## Key findings", "", - f"- The gfx942 deterministic GEMM scalar fallback costs " - f"{ratio_range(gemm_rows)} native latency. This dominates end-to-end FFN " - "overhead.", - f"- The fused deterministic SwiGLU costs {ratio_range(swiglu_rows, 2)} " - "native " - "latency, so it is faster than the unfused PyTorch expression; it is not " - "the bottleneck.", + f"- Strict Triton GEMM costs " + f"{ratio_range(gemm_rows, 'triton_overhead_ratio')} native latency, " + f"versus {ratio_range(gemm_rows)} for the gfx942 HIP scalar fallback. " + f"That is a {ratio_range(gemm_rows, 'triton_speedup_vs_hip')} speedup " + "while preserving the identical BF16 arithmetic tree.", + f"- Strict Triton SwiGLU costs " + f"{ratio_range(swiglu_rows, 'triton_overhead_ratio', 2)} native latency; " + f"the HIP fused kernel costs {ratio_range(swiglu_rows, digits=2)}.", f"- Deterministic collectives cost {ratio_range(collective_rows)} native " "RCCL latency across 2/4/8 ranks and 64 KiB/1 MiB/16 MiB per rank.", - f"- Distributed FFN overhead is {ratio_range(forward_rows)} for forward and " - f"{ratio_range(training_rows)} for forward+backward.", - f"- All {len(distributed_rows)} distributed direction/topology cases are " - "train/inference and repeat bitwise consistent: " - f"{'yes' if consistency_rows else 'no'}.", + f"- Triton distributed FFN overhead is " + f"{ratio_range(forward_rows, 'triton_overhead_ratio')} for forward and " + f"{ratio_range(training_rows, 'triton_overhead_ratio')} for " + f"forward+backward, compared with {ratio_range(forward_rows)} and " + f"{ratio_range(training_rows)} for HIP.", + f"- HIP and Triton produced {total_triton_mismatches} mismatched elements " + f"across all measured GEMM, SwiGLU, single-GPU FFN, and distributed FFN " + "outputs/gradients. All distributed TP/CP/SP cases are repeat and " + "train/inference bitwise consistent: " + f"HIP={'yes' if consistency_rows else 'no'}, " + f"Triton={'yes' if triton_consistency_rows else 'no'}.", f"- GEMM relative-L2 error against FP32 is " f"{min(gemm_deterministic_errors):.3f}-{max(gemm_deterministic_errors):.3f}% " f"for the deterministic BF16 tree versus " @@ -1384,15 +1628,20 @@ def ratio_range(rows: list[dict[str, Any]], digits: int = 1) -> str: "", "## Single-GPU GEMM", "", - "| Shape | Native ROCm (ms) | Deterministic (ms) | Overhead | " - "Det rel-L2 vs FP32 | Native rel-L2 vs FP32 |", - "|---|---:|---:|---:|---:|---:|", + "| Shape | Native (ms) | Strict HIP (ms) | Strict Triton (ms) | " + "HIP/native | Triton/native | Triton speedup | Mismatch | " + "Strict rel-L2 vs FP32 | Native rel-L2 vs FP32 |", + "|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|", ) ) for row in gemm_rows: lines.append( f"| {row['name']} | {row['native']['median_ms']:.4f} | " - f"{row['deterministic']['median_ms']:.4f} | {row['overhead_ratio']:.1f}× | " + f"{row['deterministic']['median_ms']:.4f} | " + f"{row['triton']['median_ms']:.4f} | {row['overhead_ratio']:.1f}× | " + f"{row['triton_overhead_ratio']:.1f}× | " + f"{row['triton_speedup_vs_hip']:.1f}× | " + f"{row['triton_vs_hip_mismatch_count']} | " f"{row['deterministic_vs_fp32']['relative_l2']:.3e} | " f"{row['native_vs_fp32']['relative_l2']:.3e} |" ) @@ -1402,16 +1651,21 @@ def ratio_range(rows: list[dict[str, Any]], digits: int = 1) -> str: "", "## Single-GPU SwiGLU", "", - "| Case | Native PyTorch (ms) | Deterministic fused (ms) | Det/native | " - "Det/native rel-L2 |", - "|---|---:|---:|---:|---:|", + "| Case | Native PyTorch (ms) | Strict HIP (ms) | Strict Triton (ms) | " + "HIP/native | Triton/native | Triton speedup | Mismatch | " + "Strict/native rel-L2 |", + "|---|---:|---:|---:|---:|---:|---:|---:|---:|", ) ) for row in swiglu_rows: lines.append( f"| {row['name']} | {row['native']['median_ms']:.4f} | " f"{row['deterministic']['median_ms']:.4f} | " + f"{row['triton']['median_ms']:.4f} | " f"{row['overhead_ratio']:.2f}x | " + f"{row['triton_overhead_ratio']:.2f}x | " + f"{row['triton_speedup_vs_hip']:.2f}x | " + f"{row['triton_vs_hip_mismatch_count']} | " f"{row['deterministic_vs_native']['relative_l2']:.3e} |" ) @@ -1420,15 +1674,20 @@ def ratio_range(rows: list[dict[str, Any]], digits: int = 1) -> str: "", "## Single-GPU FFN", "", - "| Case | Native ROCm (ms) | Deterministic (ms) | Overhead | " + "| Case | Native (ms) | Strict HIP (ms) | Strict Triton (ms) | " + "HIP/native | Triton/native | Triton speedup | Mismatch | " "Output rel-L2 | Max grad rel-L2 |", - "|---|---:|---:|---:|---:|---:|", + "|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|", ) ) for row in ffn_rows: lines.append( f"| {row['name']} | {row['native']['median_ms']:.4f} | " - f"{row['deterministic']['median_ms']:.4f} | {row['overhead_ratio']:.1f}× | " + f"{row['deterministic']['median_ms']:.4f} | " + f"{row['triton']['median_ms']:.4f} | {row['overhead_ratio']:.1f}× | " + f"{row['triton_overhead_ratio']:.1f}× | " + f"{row['triton_speedup_vs_hip']:.1f}× | " + f"{row['triton_vs_hip_mismatch_count']} | " f"{row['deterministic_vs_native']['relative_l2']:.3e} | " f"{row.get('max_gradient_relative_l2', float('nan')):.3e} |" ) @@ -1461,10 +1720,10 @@ def ratio_range(rows: list[dict[str, Any]], digits: int = 1) -> str: "", "## Distributed FFN", "", - "| Topology | Direction | Native ROCm/RCCL (ms) | " - "Deterministic (ms) | Overhead | Output rel-L2 | Max grad rel-L2 | " - "Train/infer bitwise | Repeat bitwise |", - "|---|---|---:|---:|---:|---:|---:|:---:|:---:|", + "| Topology | Direction | Native (ms) | Strict HIP (ms) | " + "Strict Triton (ms) | HIP/native | Triton/native | Triton speedup | " + "Mismatch | Output rel-L2 | Max grad rel-L2 | Triton T/I | Triton repeat |", + "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|:---:|:---:|", ) ) for row in distributed_rows: @@ -1472,11 +1731,15 @@ def ratio_range(rows: list[dict[str, Any]], digits: int = 1) -> str: f"| {row['name']} | {row['direction']} | " f"{row['native']['median_ms']:.4f} | " f"{row['deterministic']['median_ms']:.4f} | " + f"{row['triton']['median_ms']:.4f} | " f"{row['overhead_ratio']:.1f}× | " + f"{row['triton_overhead_ratio']:.1f}× | " + f"{row['triton_speedup_vs_hip']:.1f}× | " + f"{row['triton_vs_hip_mismatch_count']} | " f"{row['output_relative_l2']:.3e} | " f"{row.get('max_gradient_relative_l2', float('nan')):.3e} | " - f"{'yes' if row['train_infer_bitwise'] else 'no'} | " - f"{'yes' if row['repeat_bitwise'] else 'no'} |" + f"{'yes' if row['triton_train_infer_bitwise'] else 'no'} | " + f"{'yes' if row['triton_repeat_bitwise'] else 'no'} |" ) lines.extend( @@ -1502,7 +1765,6 @@ def _write_figures(payload: dict[str, Any], output_directory: Path) -> None: matplotlib.use("Agg") import matplotlib.pyplot as plt - from matplotlib.patches import Patch plt.style.use("seaborn-v0_8-whitegrid") @@ -1514,30 +1776,39 @@ def _write_figures(payload: dict[str, Any], output_directory: Path) -> None: + [row["name"] for row in swiglu_rows] + [row["name"] for row in ffn_rows] ) - ratios = ( + hip_ratios = ( [row["overhead_ratio"] for row in gemm_rows] + [row["overhead_ratio"] for row in swiglu_rows] + [row["overhead_ratio"] for row in ffn_rows] ) - colors = ( - ["#3b82f6"] * len(gemm_rows) - + ["#10b981"] * len(swiglu_rows) - + ["#f97316"] * len(ffn_rows) + triton_ratios = ( + [row["triton_overhead_ratio"] for row in gemm_rows] + + [row["triton_overhead_ratio"] for row in swiglu_rows] + + [row["triton_overhead_ratio"] for row in ffn_rows] ) figure, axis = plt.subplots(figsize=(18, 7)) - axis.bar(range(len(labels)), ratios, color=colors) + positions = list(range(len(labels))) + width = 0.4 + axis.bar( + [position - width / 2 for position in positions], + hip_ratios, + width, + color="#ef4444", + label="Strict HIP", + ) + axis.bar( + [position + width / 2 for position in positions], + triton_ratios, + width, + color="#8b5cf6", + label="Strict Triton", + ) axis.axhline(1.0, color="black", linewidth=1) axis.set_yscale("log") - axis.set_ylabel("Deterministic / native latency (×, log scale)") - axis.set_title("MI300X single-GPU deterministic overhead") - axis.set_xticks(range(len(labels)), labels, rotation=55, ha="right") - axis.legend( - handles=( - Patch(color="#3b82f6", label="GEMM"), - Patch(color="#10b981", label="SwiGLU"), - Patch(color="#f97316", label="FFN"), - ) - ) + axis.set_ylabel("Strict / native latency (×, log scale)") + axis.set_title("MI300X single-GPU strict HIP vs Triton overhead") + axis.set_xticks(positions, labels, rotation=55, ha="right") + axis.legend() figure.tight_layout() figure.savefig(output_directory / "single_gpu_overhead.png", dpi=180) plt.close(figure) @@ -1573,16 +1844,28 @@ def _write_figures(payload: dict[str, Any], output_directory: Path) -> None: rows = payload["distributed_ffn"] labels = [f"{row['name']}\n{row['direction']}" for row in rows] figure, axis = plt.subplots(figsize=(16, 6)) + positions = list(range(len(rows))) + width = 0.4 axis.bar( - range(len(rows)), + [position - width / 2 for position in positions], [row["overhead_ratio"] for row in rows], - color=["#10b981" if row["direction"] == "forward" else "#8b5cf6" for row in rows], + width, + color="#ef4444", + label="Strict HIP", + ) + axis.bar( + [position + width / 2 for position in positions], + [row["triton_overhead_ratio"] for row in rows], + width, + color="#8b5cf6", + label="Strict Triton", ) axis.axhline(1.0, color="black", linewidth=1) axis.set_yscale("log") - axis.set_ylabel("Deterministic / native latency (×, log scale)") - axis.set_title("Qwen3-8B-shaped FFN: native ROCm/RCCL vs deterministic") - axis.set_xticks(range(len(labels)), labels, rotation=55, ha="right") + axis.set_ylabel("Strict / native latency (×, log scale)") + axis.set_title("Qwen3-8B-shaped FFN: strict HIP vs Triton on MI300X") + axis.set_xticks(positions, labels, rotation=55, ha="right") + axis.legend() figure.tight_layout() figure.savefig(output_directory / "distributed_ffn_overhead.png", dpi=180) plt.close(figure) @@ -1606,12 +1889,12 @@ def _write_figures(payload: dict[str, Any], output_directory: Path) -> None: [position + width / 2 for position in positions], deterministic_errors, width, - label="Deterministic vs FP32", + label="Strict HIP = Triton vs FP32", color="#ef4444", ) axis.set_yscale("log") axis.set_ylabel("Relative L2 error (log scale)") - axis.set_title("BF16 GEMM numerical error against FP32 reference") + axis.set_title("BF16 GEMM accuracy: strict Triton has 0 mismatch vs strict HIP") axis.set_xticks(positions, names, rotation=45, ha="right") axis.legend() figure.tight_layout() diff --git a/rl_engine/kernels/ops/triton/activation/swiglu.py b/rl_engine/kernels/ops/triton/activation/swiglu.py index 6fb66313..ad11ecc8 100644 --- a/rl_engine/kernels/ops/triton/activation/swiglu.py +++ b/rl_engine/kernels/ops/triton/activation/swiglu.py @@ -32,7 +32,7 @@ def _silu_fwd_kernel(x_ptr, y_ptr, n_elements, BLOCK: tl.constexpr): offs = pid * BLOCK + tl.arange(0, BLOCK) mask = offs < n_elements x = tl.load(x_ptr + offs, mask=mask, other=0.0).to(tl.float32) - s = 1.0 / (1.0 + tl.exp(-x)) + s = tl.div_rn(1.0, 1.0 + tl.exp(-x)) y = x * s tl.store(y_ptr + offs, y.to(y_ptr.dtype.element_ty), mask=mask) @@ -44,7 +44,7 @@ def _silu_bwd_kernel(dy_ptr, x_ptr, dx_ptr, n_elements, BLOCK: tl.constexpr): mask = offs < n_elements dy = tl.load(dy_ptr + offs, mask=mask, other=0.0).to(tl.float32) x = tl.load(x_ptr + offs, mask=mask, other=0.0).to(tl.float32) - s = 1.0 / (1.0 + tl.exp(-x)) + s = tl.div_rn(1.0, 1.0 + tl.exp(-x)) # silu'(x) = s * (1 + x * (1 - s)) dx = dy * s * (1.0 + x * (1.0 - s)) tl.store(dx_ptr + offs, dx.to(dx_ptr.dtype.element_ty), mask=mask) @@ -57,26 +57,42 @@ def _swiglu_fwd_kernel(gate_ptr, up_ptr, y_ptr, n_elements, BLOCK: tl.constexpr) mask = offs < n_elements g = tl.load(gate_ptr + offs, mask=mask, other=0.0).to(tl.float32) u = tl.load(up_ptr + offs, mask=mask, other=0.0).to(tl.float32) - s = 1.0 / (1.0 + tl.exp(-g)) + s = tl.div_rn(1.0, 1.0 + tl.exp(-g)) y = (g * s) * u tl.store(y_ptr + offs, y.to(y_ptr.dtype.element_ty), mask=mask) @triton.jit def _swiglu_bwd_kernel( - dy_ptr, gate_ptr, up_ptr, d_gate_ptr, d_up_ptr, n_elements, BLOCK: tl.constexpr + dy_ptr, gate_ptr, silu_grad_ptr, d_up_ptr, n_elements, BLOCK: tl.constexpr ): pid = tl.program_id(0) offs = pid * BLOCK + tl.arange(0, BLOCK) mask = offs < n_elements dy = tl.load(dy_ptr + offs, mask=mask, other=0.0).to(tl.float32) g = tl.load(gate_ptr + offs, mask=mask, other=0.0).to(tl.float32) - u = tl.load(up_ptr + offs, mask=mask, other=0.0).to(tl.float32) - s = 1.0 / (1.0 + tl.exp(-g)) + s = tl.div_rn(1.0, 1.0 + tl.exp(-g)) silu_g = g * s d_up = dy * silu_g - d_gate = dy * u * s * (1.0 + g * (1.0 - s)) + silu_grad = s * (1.0 + g * (1.0 - s)) tl.store(d_up_ptr + offs, d_up.to(d_up_ptr.dtype.element_ty), mask=mask) + tl.store(silu_grad_ptr + offs, silu_grad, mask=mask) + + +@triton.jit +def _swiglu_dgate_kernel( + dy_ptr, up_ptr, silu_grad_ptr, d_gate_ptr, n_elements, BLOCK: tl.constexpr +): + pid = tl.program_id(0) + offs = pid * BLOCK + tl.arange(0, BLOCK) + mask = offs < n_elements + dy = tl.load(dy_ptr + offs, mask=mask, other=0.0).to(tl.float32) + u = tl.load(up_ptr + offs, mask=mask, other=0.0).to(tl.float32) + silu_grad = tl.load(silu_grad_ptr + offs, mask=mask, other=0.0) + # The native HIP source evaluates (dy * up) * silu_grad. Persisting the + # latter as FP32 prevents LLVM from reassociating the expression across + # the function boundary and changing a BF16 tie at rare elements. + d_gate = (dy * u) * silu_grad tl.store(d_gate_ptr + offs, d_gate.to(d_gate_ptr.dtype.element_ty), mask=mask) @@ -124,11 +140,27 @@ def _launch_swiglu_bwd(dy: Tensor, gate: Tensor, up: Tensor) -> tuple[Tensor, Te up_c = up.contiguous() d_gate = torch.empty_like(gate_c) d_up = torch.empty_like(up_c) + silu_grad = torch.empty_like(gate_c, dtype=torch.float32) n = gate_c.numel() if n == 0: return d_gate, d_up grid = (triton.cdiv(n, _BLOCK),) - _swiglu_bwd_kernel[grid](dy_c, gate_c, up_c, d_gate, d_up, n, BLOCK=_BLOCK) + _swiglu_bwd_kernel[grid]( + dy_c, + gate_c, + silu_grad, + d_up, + n, + BLOCK=_BLOCK, + ) + _swiglu_dgate_kernel[grid]( + dy_c, + up_c, + silu_grad, + d_gate, + n, + BLOCK=_BLOCK, + ) return d_gate, d_up diff --git a/rl_engine/kernels/ops/triton/ffn/__init__.py b/rl_engine/kernels/ops/triton/ffn/__init__.py new file mode 100644 index 00000000..d10c7414 --- /dev/null +++ b/rl_engine/kernels/ops/triton/ffn/__init__.py @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 RL-Kernel Contributors + +from .ffn import qwen3_ffn_triton + +__all__ = ["qwen3_ffn_triton"] diff --git a/rl_engine/kernels/ops/triton/ffn/ffn.py b/rl_engine/kernels/ops/triton/ffn/ffn.py new file mode 100644 index 00000000..b716cc3e --- /dev/null +++ b/rl_engine/kernels/ops/triton/ffn/ffn.py @@ -0,0 +1,200 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 RL-Kernel Contributors +"""Distributed deterministic Qwen3 FFN assembled from ROCm Triton kernels. + +The arithmetic and sharding contract matches the native PR #325 path exactly: +BF16 is preserved at every GEMM/SwiGLU boundary, GEMMs use the canonical +FP32-leaf/BF16-node K tree, and TP reductions use the rank-ordered balanced +collective. CP gathers full token sequences before weight-gradient GEMMs so +their K tree is identical to CP=1. +""" + +from __future__ import annotations + +from typing import Any + +import torch +from torch import Tensor + +from rl_engine.kernels.ops.pytorch.ffn.ffn import ( + _all_gather_tokens, + _all_reduce_inplace, + _collective_for_group, + _reduce_scatter_tokens, + _require_parallel_group, + _validate_ffn_inputs, +) +from rl_engine.kernels.ops.triton.activation.swiglu import ( + _launch_swiglu_bwd, + _launch_swiglu_fwd, +) +from rl_engine.kernels.ops.triton.matmul.det_gemm import _triton_tree_gemm + + +def _gemm(a: Tensor, b: Tensor) -> Tensor: + return _triton_tree_gemm(a, b) + + +def _gemm_db(a: Tensor, grad_output: Tensor) -> Tensor: + return _triton_tree_gemm(a.t().contiguous(), grad_output) + + +class _TritonDeterministicFFNFunction(torch.autograd.Function): + @staticmethod + def forward( + ctx: Any, + rmsnorm_output: Tensor, + gate_weight: Tensor, + up_weight: Tensor, + down_weight: Tensor, + tp_group: Any, + cp_group: Any, + sequence_parallel: bool, + ) -> Tensor: + tp_dist = _require_parallel_group(tp_group, "tensor") + _require_parallel_group(cp_group, "context") + if sequence_parallel and tp_dist is None: + raise ValueError("sequence_parallel requires a tensor-parallel group.") + + input_shape = rmsnorm_output.shape + rmsnorm_output_2d = rmsnorm_output.reshape(-1, input_shape[-1]).contiguous() + tp_world = tp_dist.get_world_size(group=tp_group) if tp_dist is not None else 1 + gemm_tokens = rmsnorm_output_2d.size(0) * (tp_world if sequence_parallel else 1) + element_size = rmsnorm_output_2d.element_size() + min_size_bytes = max( + gemm_tokens * rmsnorm_output_2d.size(1) * element_size, + gemm_tokens * gate_weight.size(0) * element_size, + gate_weight.numel() * element_size, + up_weight.numel() * element_size, + down_weight.numel() * element_size, + ) + tp_collective = _collective_for_group(tp_group, min_size_bytes=min_size_bytes) + cp_collective = _collective_for_group(cp_group, min_size_bytes=min_size_bytes) + + if sequence_parallel: + rmsnorm_output_2d = _all_gather_tokens(rmsnorm_output_2d, tp_collective) + + gate = _gemm(rmsnorm_output_2d, gate_weight.t().contiguous()) + up = _gemm(rmsnorm_output_2d, up_weight.t().contiguous()) + activated = _launch_swiglu_fwd(gate, up) + output = _gemm(activated, down_weight.t().contiguous()) + + if sequence_parallel: + output = _reduce_scatter_tokens(output, tp_collective) + elif tp_collective is not None: + output = _all_reduce_inplace(output, tp_collective) + + ctx.save_for_backward( + rmsnorm_output_2d, + gate, + up, + activated, + gate_weight, + up_weight, + down_weight, + ) + ctx.input_shape = input_shape + ctx.tp_collective = tp_collective + ctx.cp_collective = cp_collective + ctx.sequence_parallel = sequence_parallel + return output.reshape(*input_shape[:-1], output.size(-1)) + + @staticmethod + def backward(ctx: Any, grad_output: Tensor) -> tuple[Any, ...]: + ( + rmsnorm_output, + gate, + up, + activated, + gate_weight, + up_weight, + down_weight, + ) = ctx.saved_tensors + tp_collective = ctx.tp_collective + cp_collective = ctx.cp_collective + grad_output = grad_output.reshape(-1, grad_output.size(-1)).contiguous() + if ctx.sequence_parallel: + grad_output = _all_gather_tokens(grad_output, tp_collective) + + if cp_collective is not None: + activated_full = _all_gather_tokens(activated, cp_collective) + grad_output_full = _all_gather_tokens(grad_output, cp_collective) + grad_down_weight = _gemm_db(activated_full, grad_output_full).t().contiguous() + else: + grad_down_weight = _gemm_db(activated, grad_output).t().contiguous() + + grad_activated = _gemm(grad_output, down_weight) + grad_gate, grad_up = _launch_swiglu_bwd(grad_activated, gate, up) + + if cp_collective is not None: + rmsnorm_full = _all_gather_tokens(rmsnorm_output, cp_collective) + grad_gate_full = _all_gather_tokens(grad_gate, cp_collective) + grad_up_full = _all_gather_tokens(grad_up, cp_collective) + grad_gate_weight = _gemm_db(rmsnorm_full, grad_gate_full).t().contiguous() + grad_up_weight = _gemm_db(rmsnorm_full, grad_up_full).t().contiguous() + else: + grad_gate_weight = _gemm_db(rmsnorm_output, grad_gate).t().contiguous() + grad_up_weight = _gemm_db(rmsnorm_output, grad_up).t().contiguous() + + grad_rmsnorm_from_gate = _gemm(grad_gate, gate_weight) + if ctx.sequence_parallel: + grad_rmsnorm_from_gate = _reduce_scatter_tokens( + grad_rmsnorm_from_gate, + tp_collective, + ) + elif tp_collective is not None: + grad_rmsnorm_from_gate = _all_reduce_inplace( + grad_rmsnorm_from_gate, + tp_collective, + ) + + grad_rmsnorm_from_up = _gemm(grad_up, up_weight) + if ctx.sequence_parallel: + grad_rmsnorm_from_up = _reduce_scatter_tokens( + grad_rmsnorm_from_up, + tp_collective, + ) + elif tp_collective is not None: + grad_rmsnorm_from_up = _all_reduce_inplace( + grad_rmsnorm_from_up, + tp_collective, + ) + + grad_rmsnorm_output = grad_rmsnorm_from_gate.add_(grad_rmsnorm_from_up) + return ( + grad_rmsnorm_output.reshape(ctx.input_shape), + grad_gate_weight, + grad_up_weight, + grad_down_weight, + None, + None, + None, + ) + + +def qwen3_ffn_triton( + rmsnorm_output: Tensor, + gate_weight: Tensor, + up_weight: Tensor, + down_weight: Tensor, + *, + tp_group: Any = None, + cp_group: Any = None, + sequence_parallel: bool = False, +) -> Tensor: + """Apply the distributed deterministic Qwen3 FFN with Triton kernels.""" + + _validate_ffn_inputs(rmsnorm_output, gate_weight, up_weight, down_weight) + if not isinstance(sequence_parallel, bool): + raise TypeError( + f"sequence_parallel must be a bool, got {type(sequence_parallel)!r}." + ) + return _TritonDeterministicFFNFunction.apply( + rmsnorm_output, + gate_weight, + up_weight, + down_weight, + tp_group, + cp_group, + sequence_parallel, + ) diff --git a/rl_engine/kernels/ops/triton/matmul/det_gemm.py b/rl_engine/kernels/ops/triton/matmul/det_gemm.py index 50025db2..4f641dbf 100644 --- a/rl_engine/kernels/ops/triton/matmul/det_gemm.py +++ b/rl_engine/kernels/ops/triton/matmul/det_gemm.py @@ -1,12 +1,24 @@ # SPDX-License-Identifier: Apache-2.0 # Copyright (c) 2026 RL-Kernel Contributors -"""Batch-invariant deterministic GEMM, Triton path (WS1). +"""Batch- and TP-invariant deterministic GEMM, Triton path. -Portable implementation with the SAME invariance guarantees as the CUDA path: -autotune disabled, BLOCK sizes pinned, no split-K, fixed K-loop order, FP32 -accumulation, no TF32. Used as the cross-backend reference and the ROCm/portable -fallback. Slower than a tuned GEMM by design. +BF16 outputs use the same arithmetic graph as the native deterministic kernel: +each canonical K-tree leaf contains at most 32 values, accumulates in FP32, and +rounds to BF16. Separate Triton kernels then evaluate the canonical midpoint +tree with BF16 nodes. The strict ROCm leaf keeps the native gfx942 scalar FMA +order so both implementations have zero mismatch; a future MFMA leaf requires +a separately versioned arithmetic contract because its internal accumulation +does not match the scalar reference at every BF16 rounding boundary. + +Autotuning and split-K are intentionally disabled. FP32-output calls preserve +the earlier fixed-order, no-split-K contract and do not use BF16 tree nodes. """ + +from __future__ import annotations + +import threading +from dataclasses import dataclass + import torch try: @@ -22,12 +34,206 @@ # Pinned. NOT autotuned (autotune picks per-shape configs -> breaks invariance). _BLOCK_M, _BLOCK_N, _BLOCK_K = 64, 64, 32 +_TREE_PLANS: dict[tuple[int, int], "_DeviceTreePlan"] = {} +_TREE_PLAN_LOCK = threading.Lock() + + +@dataclass(frozen=True) +class _TreePlan: + leaf_starts: tuple[int, ...] + leaf_lengths: tuple[int, ...] + leaf_nodes: tuple[int, ...] + reduction_levels: tuple[tuple[tuple[int, int, int], ...], ...] + root: int + node_count: int + + +@dataclass(frozen=True) +class _DeviceTreePlan: + host: _TreePlan + leaf_starts: torch.Tensor + leaf_lengths: torch.Tensor + leaf_nodes: torch.Tensor + reduction_levels: tuple[tuple[torch.Tensor, torch.Tensor, torch.Tensor], ...] + + +def _build_tree_plan(k_size: int) -> _TreePlan: + if k_size <= 0: + raise ValueError(f"deterministic GEMM K must be positive, got {k_size}") + + leaf_starts: list[int] = [] + leaf_lengths: list[int] = [] + leaf_nodes: list[int] = [] + reductions_by_height: dict[int, list[tuple[int, int, int]]] = {} + next_node = 0 + + def visit(begin: int, end: int) -> tuple[int, int]: + nonlocal next_node + if end - begin <= _BLOCK_K: + node = next_node + next_node += 1 + leaf_starts.append(begin) + leaf_lengths.append(end - begin) + leaf_nodes.append(node) + return node, 0 + + midpoint = begin + (end - begin) // 2 + lower, lower_height = visit(begin, midpoint) + upper, upper_height = visit(midpoint, end) + node = next_node + next_node += 1 + height = max(lower_height, upper_height) + 1 + reductions_by_height.setdefault(height, []).append((lower, upper, node)) + return node, height + + root, max_height = visit(0, k_size) + reduction_levels = tuple( + tuple(reductions_by_height.get(height, ())) + for height in range(1, max_height + 1) + ) + return _TreePlan( + leaf_starts=tuple(leaf_starts), + leaf_lengths=tuple(leaf_lengths), + leaf_nodes=tuple(leaf_nodes), + reduction_levels=reduction_levels, + root=root, + node_count=next_node, + ) + + +def _device_tree_plan(k_size: int, device: torch.device) -> _DeviceTreePlan: + device_index = device.index if device.index is not None else torch.cuda.current_device() + key = (device_index, k_size) + with _TREE_PLAN_LOCK: + cached = _TREE_PLANS.get(key) + if cached is not None: + return cached + + host = _build_tree_plan(k_size) + + def indices(values: tuple[int, ...]) -> torch.Tensor: + return torch.tensor(values, dtype=torch.int32, device=device) + + levels = [] + for operations in host.reduction_levels: + lower, upper, output = zip(*operations, strict=True) + levels.append((indices(lower), indices(upper), indices(output))) + result = _DeviceTreePlan( + host=host, + leaf_starts=indices(host.leaf_starts), + leaf_lengths=indices(host.leaf_lengths), + leaf_nodes=indices(host.leaf_nodes), + reduction_levels=tuple(levels), + ) + _TREE_PLANS[key] = result + return result if _TRITON_AVAILABLE: @triton.jit - def _det_gemm_kernel( + def _det_gemm_tree_leaf_kernel( + a_ptr, + b_ptr, + workspace_ptr, + leaf_starts_ptr, + leaf_lengths_ptr, + leaf_nodes_ptr, + M: tl.constexpr, + N: tl.constexpr, + K: tl.constexpr, + stride_am: tl.constexpr, + stride_ak: tl.constexpr, + stride_bk: tl.constexpr, + stride_bn: tl.constexpr, + BLOCK_M: tl.constexpr, + BLOCK_N: tl.constexpr, + BLOCK_K: tl.constexpr, + ): + leaf = tl.program_id(0) + pid_m = tl.program_id(1) + pid_n = tl.program_id(2) + offs_m = pid_m * BLOCK_M + tl.arange(0, BLOCK_M) + offs_n = pid_n * BLOCK_N + tl.arange(0, BLOCK_N) + leaf_start = tl.load(leaf_starts_ptr + leaf) + leaf_length = tl.load(leaf_lengths_ptr + leaf) + leaf_node = tl.load(leaf_nodes_ptr + leaf) + acc = tl.zeros((BLOCK_M, BLOCK_N), dtype=tl.float32) + # Keep the leaf's ascending scalar FMA order identical to the native + # gfx942 correctness kernel. A tl.dot/MFMA leaf is topology-stable but + # differs from the scalar reference at rare BF16 rounding boundaries. + for offset in tl.static_range(0, BLOCK_K): + k_offset = leaf_start + offset + active = offset < leaf_length + a = tl.load( + a_ptr + offs_m * stride_am + k_offset * stride_ak, + mask=(offs_m < M) & active, + other=0.0, + ).to(tl.float32) + b = tl.load( + b_ptr + k_offset * stride_bk + offs_n * stride_bn, + mask=(offs_n < N) & active, + other=0.0, + ).to(tl.float32) + acc += a[:, None] * b[None, :] + output_offsets = leaf_node * M * N + offs_m[:, None] * N + offs_n[None, :] + output_mask = (offs_m[:, None] < M) & (offs_n[None, :] < N) + tl.store( + workspace_ptr + output_offsets, + acc.to(workspace_ptr.dtype.element_ty), + mask=output_mask, + ) + + @triton.jit + def _det_gemm_tree_reduce_kernel( + workspace_ptr, + lower_nodes_ptr, + upper_nodes_ptr, + output_nodes_ptr, + M: tl.constexpr, + N: tl.constexpr, + BLOCK: tl.constexpr, + ): + operation = tl.program_id(0) + block = tl.program_id(1) + offsets = block * BLOCK + tl.arange(0, BLOCK) + elements = M * N + mask = offsets < elements + lower_node = tl.load(lower_nodes_ptr + operation) + upper_node = tl.load(upper_nodes_ptr + operation) + output_node = tl.load(output_nodes_ptr + operation) + lower = tl.load( + workspace_ptr + lower_node * elements + offsets, + mask=mask, + other=0.0, + ).to(tl.float32) + upper = tl.load( + workspace_ptr + upper_node * elements + offsets, + mask=mask, + other=0.0, + ).to(tl.float32) + result = lower + upper + tl.store( + workspace_ptr + output_node * elements + offsets, + result.to(workspace_ptr.dtype.element_ty), + mask=mask, + ) + + @triton.jit + def _copy_tree_root_kernel( + workspace_ptr, + output_ptr, + root, + elements, + BLOCK: tl.constexpr, + ): + offsets = tl.program_id(0) * BLOCK + tl.arange(0, BLOCK) + mask = offsets < elements + values = tl.load(workspace_ptr + root * elements + offsets, mask=mask) + tl.store(output_ptr + offsets, values, mask=mask) + + @triton.jit + def _det_gemm_fp32_kernel( a_ptr, b_ptr, c_ptr, @@ -72,18 +278,13 @@ def _det_gemm_kernel( tl.store(c_ptrs, c, mask=mask) -def _triton_gemm(a, b, *, output_dtype=None): +def _triton_gemm_fp32(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor: a, b = a.contiguous(), b.contiguous() M, K = a.shape _, N = b.shape - c = torch.empty( - (M, N), device=a.device, dtype=a.dtype if output_dtype is None else output_dtype - ) + c = torch.empty((M, N), device=a.device, dtype=torch.float32) grid = (triton.cdiv(M, _BLOCK_M), triton.cdiv(N, _BLOCK_N)) - promote_inputs = ( - output_dtype == torch.float32 or a.dtype == torch.float32 or b.dtype == torch.float32 - ) - _det_gemm_kernel[grid]( + _det_gemm_fp32_kernel[grid]( a, b, c, @@ -99,31 +300,103 @@ def _triton_gemm(a, b, *, output_dtype=None): BLOCK_M=_BLOCK_M, BLOCK_N=_BLOCK_N, BLOCK_K=_BLOCK_K, - PROMOTE_INPUTS=promote_inputs, + PROMOTE_INPUTS=True, ) return c +def _triton_tree_gemm(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor: + if not _TRITON_AVAILABLE: + raise RuntimeError("Triton is unavailable") + if a.dim() != 2 or b.dim() != 2: + raise ValueError("Triton deterministic GEMM expects two 2-D tensors") + if a.size(1) != b.size(0): + raise ValueError(f"Triton deterministic GEMM K mismatch: {a.size(1)} and {b.size(0)}") + if a.dtype != torch.bfloat16 or b.dtype != torch.bfloat16: + raise TypeError("Triton tree GEMM requires BF16 inputs") + if not a.is_cuda or not b.is_cuda or a.device != b.device: + raise RuntimeError("Triton tree GEMM inputs must share one CUDA/ROCm device") + + a = a.contiguous() + b = b.contiguous() + m_size, k_size = a.shape + n_size = b.size(1) + plan = _device_tree_plan(k_size, a.device) + workspace = torch.empty( + (plan.host.node_count, m_size, n_size), + dtype=torch.bfloat16, + device=a.device, + ) + leaf_grid = ( + len(plan.host.leaf_nodes), + triton.cdiv(m_size, _BLOCK_M), + triton.cdiv(n_size, _BLOCK_N), + ) + _det_gemm_tree_leaf_kernel[leaf_grid]( + a, + b, + workspace, + plan.leaf_starts, + plan.leaf_lengths, + plan.leaf_nodes, + M=m_size, + N=n_size, + K=k_size, + stride_am=a.stride(0), + stride_ak=a.stride(1), + stride_bk=b.stride(0), + stride_bn=b.stride(1), + BLOCK_M=_BLOCK_M, + BLOCK_N=_BLOCK_N, + BLOCK_K=_BLOCK_K, + ) + reduction_block = 256 + for operations, (lower, upper, output) in zip( + plan.host.reduction_levels, + plan.reduction_levels, + strict=True, + ): + grid = (len(operations), triton.cdiv(m_size * n_size, reduction_block)) + _det_gemm_tree_reduce_kernel[grid]( + workspace, + lower, + upper, + output, + M=m_size, + N=n_size, + BLOCK=reduction_block, + ) + + result = torch.empty((m_size, n_size), dtype=torch.bfloat16, device=a.device) + copy_block = 256 + _copy_tree_root_kernel[(triton.cdiv(result.numel(), copy_block),)]( + workspace, + result, + plan.host.root, + result.numel(), + BLOCK=copy_block, + ) + return result + + class _TritonDetGemmFn(torch.autograd.Function): @staticmethod def forward(ctx, a, b, output_fp32=False): ctx.save_for_backward(a, b) ctx.output_fp32 = bool(output_fp32) - return _triton_gemm(a, b, output_dtype=torch.float32 if output_fp32 else None) + return _triton_gemm_fp32(a, b) if output_fp32 else _triton_tree_gemm(a, b) @staticmethod def backward(ctx, grad_out): a, b = ctx.saved_tensors grad_out = grad_out.contiguous() da = ( - _triton_gemm(grad_out, b.t().contiguous(), output_dtype=torch.float32) - .reshape_as(a) - .to(a.dtype) + _triton_tree_gemm(grad_out.to(torch.bfloat16), b.t().contiguous()).reshape_as(a) if ctx.needs_input_grad[0] else None ) db = ( - _triton_gemm(a.t().contiguous(), grad_out, output_dtype=torch.float32).to(b.dtype) + _triton_tree_gemm(a.t().contiguous(), grad_out.to(torch.bfloat16)) if ctx.needs_input_grad[1] else None ) diff --git a/tests/distributed/test_qwen_ffn_topology.py b/tests/distributed/test_qwen_ffn_topology.py index 44de9041..96717684 100644 --- a/tests/distributed/test_qwen_ffn_topology.py +++ b/tests/distributed/test_qwen_ffn_topology.py @@ -28,6 +28,7 @@ QWEN3_8B_INTERMEDIATE_SIZE, qwen3_ffn, ) +from rl_engine.kernels.ops.triton.ffn import qwen3_ffn_triton _REQUIRED_FFN_SYMBOLS = ( "det_gemm_fwd", @@ -182,6 +183,14 @@ def _canonical( return inference, training, inputs +def _ffn_implementation(name: str): + if name == "native": + return qwen3_ffn + if name == "triton": + return qwen3_ffn_triton + raise ValueError(f"unknown FFN implementation: {name}") + + def _mesh_groups( dist: Any, tp_size: int, @@ -226,6 +235,7 @@ def _run_topology( inference_reference: torch.Tensor, training_reference: torch.Tensor, reference_inputs: list[torch.Tensor], + implementation: str = "native", ) -> None: mesh_key = (tp_size, cp_size) if mesh_key not in meshes: @@ -251,15 +261,16 @@ def _run_topology( down[:, feature_start:feature_end].contiguous(), ) + target_ffn = _ffn_implementation(implementation) with torch.no_grad(): - inference = qwen3_ffn( + inference = target_ffn( *shard, tp_group=tp_group, cp_group=cp_group, sequence_parallel=sequence_parallel, ) inputs = [value.detach().clone().requires_grad_(True) for value in shard] - training = qwen3_ffn( + training = target_ffn( *inputs, tp_group=tp_group, cp_group=cp_group, @@ -296,6 +307,7 @@ def _topology_worker( init_method: str, result_queue: Any, configs: tuple[tuple[str, int, int, bool], ...], + implementation: str = "native", ) -> None: try: import torch.distributed as dist @@ -341,6 +353,7 @@ def _topology_worker( inference_reference=inference_reference, training_reference=training_reference, reference_inputs=reference_inputs, + implementation=implementation, ) result_queue.put({"ok": True, "rank": rank}) except Exception: # pragma: no cover - forwarded to the parent process. @@ -504,6 +517,33 @@ def test_qwen3_ffn_tp8_matches_tp1_bitwise() -> None: ) +def test_qwen3_ffn_triton_tp2_and_tp_sp_match_native_tp1_bitwise() -> None: + _spawn_workers( + _topology_worker, + 2, + (_WORLD2_CONFIGS, "triton"), + timeout_seconds=240, + ) + + +def test_qwen3_ffn_triton_tp4_tp_cp_and_tp_cp_sp_match_native_tp1_bitwise() -> None: + _spawn_workers( + _topology_worker, + 4, + (_WORLD4_CONFIGS, "triton"), + timeout_seconds=300, + ) + + +def test_qwen3_ffn_triton_tp8_matches_native_tp1_bitwise() -> None: + _spawn_workers( + _topology_worker, + 8, + (_WORLD8_CONFIGS, "triton"), + timeout_seconds=420, + ) + + def test_qwen3_8b_ffn_tp2_smoke_matches_tp1_bitwise() -> None: if os.environ.get("RL_KERNEL_SKIP_QWEN3_8B_TOPOLOGY") == "1": pytest.skip("Qwen3-8B topology smoke disabled by environment") diff --git a/tests/test_det_gemm.py b/tests/test_det_gemm.py index 159eddb4..306f42e2 100644 --- a/tests/test_det_gemm.py +++ b/tests/test_det_gemm.py @@ -153,7 +153,7 @@ def test_forward_correctness(name, gemm): M, K, N = 128, 2048, 2048 a, b = _rand(M, K), _rand(K, N) out = gemm(a, b).float() - ref = _k_tree_gemm(a, b).float() if name == _NATIVE_BACKEND else a.float() @ b.float() + ref = _k_tree_gemm(a, b).float() contract = load_contract() thresholds = contract["accuracy"]["default"]["reduction"]["bfloat16"] torch.testing.assert_close(out, ref, atol=thresholds["atol"], rtol=thresholds["rtol"]) @@ -209,35 +209,21 @@ def test_backward_correctness(name, gemm): b = _rand(K, N).requires_grad_(True) g = _rand(M, N) gemm(a, b).backward(g) - if name == _NATIVE_BACKEND: - expected_da = _k_tree_gemm(g, b.detach().t().contiguous()) - expected_db = _k_tree_gemm(a.detach().t().contiguous(), g) - contract = load_contract() - thresholds = contract["accuracy"]["default"]["reduction"]["bfloat16"] - torch.testing.assert_close( - a.grad.float(), - expected_da.float(), - atol=thresholds["atol"], - rtol=thresholds["rtol"], - ) - torch.testing.assert_close( - b.grad.float(), - expected_db.float(), - atol=thresholds["atol"], - rtol=thresholds["rtol"], - ) - return - - af = a.detach().float().requires_grad_(True) - bf = b.detach().float().requires_grad_(True) - (af @ bf).backward(g.float()) + expected_da = _k_tree_gemm(g, b.detach().t().contiguous()) + expected_db = _k_tree_gemm(a.detach().t().contiguous(), g) contract = load_contract() thresholds = contract["accuracy"]["default"]["reduction"]["bfloat16"] torch.testing.assert_close( - a.grad.float(), af.grad, atol=thresholds["atol"], rtol=thresholds["rtol"] + a.grad.float(), + expected_da.float(), + atol=thresholds["atol"], + rtol=thresholds["rtol"], ) torch.testing.assert_close( - b.grad.float(), bf.grad, atol=thresholds["atol"], rtol=thresholds["rtol"] + b.grad.float(), + expected_db.float(), + atol=thresholds["atol"], + rtol=thresholds["rtol"], ) @@ -274,10 +260,43 @@ def test_triton_ragged_tiles_mask_all_axes(): out = deterministic_gemm_triton(a, b) torch.cuda.synchronize() assert tuple(out.shape) == (80, 129) - torch.testing.assert_close( - out.float(), a.detach().float() @ b.detach().float(), atol=5e-2, rtol=2e-2 - ) + assert torch.equal(out, deterministic_gemm(a.detach(), b.detach())) out.backward(_rand(80, 129)) torch.cuda.synchronize() assert torch.isfinite(a.grad).all() assert torch.isfinite(b.grad).all() + + +@pytest.mark.skipif(not _HAS_TRITON, reason="Triton is unavailable") +@pytest.mark.parametrize("shape", ((4, 65, 129), (8, 4096, 128), (4, 12288, 64))) +def test_triton_tree_matches_native_forward_bitwise(shape): + """Triton evaluates the native FP32-leaf/BF16-node tree exactly.""" + + torch.manual_seed(47) + m_size, k_size, n_size = shape + a = _rand(m_size, k_size) + b = _rand(k_size, n_size) + + native = deterministic_gemm(a, b) + triton_output = deterministic_gemm_triton(a, b) + + assert torch.equal(native, triton_output), ( + f"Triton/native mismatch at {shape}: " + f"{int((native != triton_output).sum().item())} elements" + ) + + +@pytest.mark.skipif(not _HAS_TRITON, reason="Triton is unavailable") +def test_triton_tree_matches_native_backward_bitwise(): + torch.manual_seed(48) + a = _rand(32, 512) + b = _rand(512, 128) + grad_output = _rand(32, 128) + native_inputs = [value.detach().clone().requires_grad_(True) for value in (a, b)] + triton_inputs = [value.detach().clone().requires_grad_(True) for value in (a, b)] + + deterministic_gemm(*native_inputs).backward(grad_output) + deterministic_gemm_triton(*triton_inputs).backward(grad_output) + + for native, triton_input in zip(native_inputs, triton_inputs, strict=True): + assert torch.equal(native.grad, triton_input.grad) diff --git a/tests/test_qwen_ffn.py b/tests/test_qwen_ffn.py index e0c4a18f..c86fc7c4 100644 --- a/tests/test_qwen_ffn.py +++ b/tests/test_qwen_ffn.py @@ -25,6 +25,7 @@ QWEN3_8B_INTERMEDIATE_SIZE, qwen3_ffn, ) +from rl_engine.kernels.ops.triton.ffn import qwen3_ffn_triton from rl_engine.platforms.device import device_ctx _REQUIRED_SYMBOLS = ( @@ -362,3 +363,67 @@ def test_qwen3_ffn_gpu_output_and_hidden_gradient_are_token_slice_invariant(): assert torch.equal(slice_output, full_output[2:4]) assert torch.equal(slice_hidden.grad, full_hidden.grad[2:4]) + + +@requires_gpu_ffn +@pytest.mark.parametrize("shape", ((7, 64, 128), (32, 64, 512))) +def test_qwen3_ffn_triton_matches_native_forward_and_backward_bitwise(shape): + device = device_ctx.device + tokens, hidden_size, intermediate_size = shape + values = ( + _randn((tokens, hidden_size), seed=50, dtype=torch.bfloat16, device=device), + _randn( + (intermediate_size, hidden_size), + seed=51, + dtype=torch.bfloat16, + device=device, + ), + _randn( + (intermediate_size, hidden_size), + seed=52, + dtype=torch.bfloat16, + device=device, + ), + _randn( + (hidden_size, intermediate_size), + seed=53, + dtype=torch.bfloat16, + device=device, + ), + ) + grad_output = _randn( + (tokens, hidden_size), + seed=54, + dtype=torch.bfloat16, + device=device, + ) + native_inputs = [value.detach().clone().requires_grad_(True) for value in values] + triton_inputs = [value.detach().clone().requires_grad_(True) for value in values] + + native_output = qwen3_ffn(*native_inputs) + triton_output = qwen3_ffn_triton(*triton_inputs) + native_output.backward(grad_output) + triton_output.backward(grad_output) + + assert torch.equal(native_output, triton_output) + for native, triton_input in zip(native_inputs, triton_inputs, strict=True): + assert torch.equal(native.grad, triton_input.grad) + + +@requires_gpu_ffn +def test_qwen3_ffn_triton_repeat_and_train_infer_are_bitwise(): + device = device_ctx.device + values = ( + _randn((8, 64), seed=60, dtype=torch.bfloat16, device=device), + _randn((128, 64), seed=61, dtype=torch.bfloat16, device=device), + _randn((128, 64), seed=62, dtype=torch.bfloat16, device=device), + _randn((64, 128), seed=63, dtype=torch.bfloat16, device=device), + ) + with torch.no_grad(): + first = qwen3_ffn_triton(*values) + second = qwen3_ffn_triton(*values) + training_values = [value.detach().clone().requires_grad_(True) for value in values] + training = qwen3_ffn_triton(*training_values) + + assert torch.equal(first, second) + assert torch.equal(first, training.detach()) diff --git a/tests/test_swiglu.py b/tests/test_swiglu.py index 22b26336..555d3bc4 100644 --- a/tests/test_swiglu.py +++ b/tests/test_swiglu.py @@ -372,6 +372,34 @@ def test_cuda_triton_swiglu_matches_native_forward_and_backward(impl, dtype, sha ) +@requires_cuda_activation +@requires_triton_activation +def test_triton_swiglu_matches_hip_bitwise_at_qwen3_width(): + shape = (32, _INTERMEDIATE) + values = tuple( + (_rand(shape, seed=seed, dtype=torch.float32) * 0.02).to( + device="cuda", dtype=torch.bfloat16 + ) + for seed in (35, 36) + ) + grad_output = (_rand(shape, seed=37, dtype=torch.float32) * 0.02).to( + device="cuda", dtype=torch.bfloat16 + ) + hip_inputs = [value.detach().clone().requires_grad_(True) for value in values] + triton_inputs = [value.detach().clone().requires_grad_(True) for value in values] + + hip_output = SwiGLUCudaOp().forward(*hip_inputs) + triton_output = TritonSwiGLUOp().forward(*triton_inputs) + hip_output.backward(grad_output) + triton_output.backward(grad_output) + + assert torch.equal(hip_output, triton_output) + assert all( + torch.equal(hip_input.grad, triton_input.grad) + for hip_input, triton_input in zip(hip_inputs, triton_inputs, strict=True) + ) + + @requires_cuda @pytest.mark.parametrize("impl", _silu_impls()) def test_cuda_triton_silu_batch_invariance_bitwise(impl): From 809789c3011079307b338a177a3768ebed598beb Mon Sep 17 00:00:00 2001 From: frank-2077 Date: Sun, 23 Aug 2026 02:50:03 +0000 Subject: [PATCH 09/28] docs: report MI300X Triton FFN performance --- benchmarks/benchmark_rocm_ffn.py | 39 + .../pr325_rocm_mi300x/accuracy_tradeoff.png | Bin 93854 -> 96007 bytes .../pr325_rocm_mi300x/collective_overhead.png | Bin 168873 -> 172309 bytes .../distributed_ffn_overhead.png | Bin 92815 -> 93551 bytes .../results/pr325_rocm_mi300x/report.md | 170 +- .../results/pr325_rocm_mi300x/results.json | 1626 +++++++++++------ .../pr325_rocm_mi300x/single_gpu_overhead.png | Bin 213116 -> 213251 bytes 7 files changed, 1153 insertions(+), 682 deletions(-) diff --git a/benchmarks/benchmark_rocm_ffn.py b/benchmarks/benchmark_rocm_ffn.py index 8216d736..c6513bdc 100644 --- a/benchmarks/benchmark_rocm_ffn.py +++ b/benchmarks/benchmark_rocm_ffn.py @@ -1526,6 +1526,13 @@ def ratio_range( distributed_output_errors = [ row["output_relative_l2"] * 100.0 for row in distributed_rows ] + one_mib_collective_ms = [ + row["deterministic"]["median_ms"] + for row in collective_rows + if row["message_bytes_per_rank"] == _MIB + ] + triton_forward_ms = [row["triton"]["median_ms"] for row in forward_rows] + triton_training_ms = [row["triton"]["median_ms"] for row in training_rows] consistency_rows = all( row["train_infer_bitwise"] and row["repeat_bitwise"] for row in distributed_rows @@ -1742,6 +1749,38 @@ def ratio_range( f"{'yes' if row['triton_repeat_bitwise'] else 'no'} |" ) + lines.extend( + ( + "", + "## Communication overlap feasibility", + "", + "The reported implementations deliberately serialize compute and " + "communication; the tables above do not claim overlap. A representative " + f"1 MiB strict collective costs {min(one_mib_collective_ms):.4f}-" + f"{max(one_mib_collective_ms):.4f} ms, while Triton distributed FFN " + f"forward costs {min(triton_forward_ms):.4f}-" + f"{max(triton_forward_ms):.4f} ms and forward+backward costs " + f"{min(triton_training_ms):.4f}-{max(triton_training_ms):.4f} ms. " + "Communication is therefore material after the GEMM speedup, but only " + "some calls are structurally hideable.", + "", + "- Forward SP all-gather feeds both gate/up GEMMs, and the final TP " + "all-reduce or reduce-scatter consumes the down projection. These are " + "dependency boundaries and cannot be hidden by simply moving them to " + "another stream.", + "- Backward has one safe pipeline candidate: launch the fixed-order TP " + "reduction for the gate contribution to `dHidden`, compute the independent " + "up contribution, then wait and add in the existing gate-then-up order. " + "The rank tree and BF16 addition order must remain unchanged.", + "- CP activation/gradient gathers are prerequisites for weight-gradient " + "GEMMs. They can be coalesced into a fixed packed layout to amortize " + "launch/signature validation, but are not naturally hidden by those GEMMs.", + "- Because the plausible overlap window is bounded by roughly one strict " + "collective, coalescing and removing per-call host signature validation " + "should be benchmarked before adding multi-stream scheduling complexity.", + ) + ) + lines.extend( ( "", diff --git a/benchmarks/results/pr325_rocm_mi300x/accuracy_tradeoff.png b/benchmarks/results/pr325_rocm_mi300x/accuracy_tradeoff.png index e6996416e60515f0b15367ade6b79212df897de9..8698866997c84ed13e0f09b24965c65d2728415d 100644 GIT binary patch literal 96007 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�N-ce7_N#~^B|4~3nW%f+?T&27yRxA#*}mgoHOm8Y3&aEc%=^H_7U z8OXkJz`Mo%!dyK)J%Ea5dSF6Po4CnLhtq2oxMbDIu6TCa*#;AT^MMF2K#ePm2L0PE z>~M%0F9MBMPq)>D^7&j+k|-O*2j5$y27&dR!^IV{k4<-DSI)&F;=lZI0TY8Ts(B;Y zbls@2MQ5<%=%v~Vb>n+fK=gn{EPQrqC9@?mzVP@ocH$ymzkOSR6@d<9IUs_9`}coC z&89zQk?-NSR&?ZIidwo|!zEnZ2c31W1QozH?&3+#czat6_O={6bO_Yo^e^_8qqq{Q zhE0YY^gC|iJuprm;M{EM*RLNyN5`$ZE%q|Mgp@J(_#R{PVmpy?a-pmv;{-cr zD^6>?PV#XmPkK-e1?!L`FW?wXX$JEcFwQW%z8o{{Oa@D&O%^CcB8CyU}$LdtyPXrPS@5Qo7xP*8Mk>M zG_({e;2^_|%VT*&n0yP5q=3)<{p3lKr9&XT%JN1B7=^%X%OPapEWfmteK@N*;UDJ| zyVi!3ZGzM&^rMXV!+C9&=iR}%Q32laJkyCEoo1wIfGUq?Ex*9@NGNb0f+;_U4jgEt zId2*}2LruCxaHlb3#dJ2IaVbZt6^5?s$cjV!-WkpF5vj7r&+0^3Vjo_Vc6yv0k}Ou zPtub^SXoDB!MIz|^jTS9CJw8L`ZsR$=Z(Tyf{L(Y@cZl7x2yKm1}b`S%;Dit!8?eR zj}iOH=djv*K3--4)J(dWj(o6a*RX1|`LQ9bs}pBY@0Zw8&Kogo^pZ`cVU*eR?N`>L5z{ndV`CU1He4|Z<1g9D zPuUmjO77Va*K)d64vfRxys=R^MbCM=Q5VpRo~#iOjJ6z8bozSV-#>j9$fXDQ`7!@c z?3!!3y#t%11?=-xEQlLQG)Yec{O&g#M$DZr2A)*}q#OgPr5y@g*jCw8 zokii0Nooy-CfXb2wcAAD*2htkKt7?ZsC02 z!XMUQ%(j4L^pBD@RSYpPA51$)Jhq<$IKtnrk*;zWl?~L;cL+EKcj1KHqhgF zE4F(~oiSR6nfA0HX+*{G^5z?OAI8PT4)+met21bbDiXV}!_9+5-P z^fXTUJjw~LANsEA)vIH0JhZBy^0?((&O#-){l>0e(YTbhnkS~xChk$}I_AYGnzH-; zKeDs4-_&K@a`F?z@XyAEg`V&`-!y`Q!;wZh;q%!FB}(!7x4db{A!a|eUA~xnD74Jt z+Qu_KX~ygLl!Zt;y}CC|dr8U`e;51*9L9`w*x$$A?iOkq`iPnB@y2r%0OwKAP9a%hvmbkc1{yX@6VVg(*7?cFtP z`t-Sr7Ad1#H(LLe2H9Jm8a^p0|HW$$ z-Ebc}3KNMQ@q1V7j9;+a_Y7=riq&J@^nG>8=)^_xkI>(=c^wa6k7Gz18_qM^*uJ>e zuU`EMpG^CkUo~_WpwR~p9>^$UVX=)c^i}Vs^$84=-|B755JI)GIkx%573#-fx!86k z4}Tsg%dm_$$P~wcE=2f&@z#3_Hg;WuYe>fZV7lIx7>!7er_OtZv#?pAGOelEaqd^4 zIhnW4ZeM1Q$8iKglCTPU6BCm+wV4v|j8`$|l|b)oC`$}(?>__QdBdV?k%)2bwnT%> zXpG}d|7Kq1=CjZ2xMxp?0Vwa8ZF*G|d*{r#bA0fJh+j@(JKLiX5%S$Y83$haQrL7H zzx(-?yiCbAGc`9drZrv7gK%`=Xf9MXj+0}Oqo;G?{y0Wi6&`{)|HC@|Dv*mZIWJ0g|mJ3_b*AFqSTO?+P4 zV?*;|v7l|`)2r{^y$dq||1rDNLV{Do;4)M+4fS_dfaupvF`FTp{eCLkQl)c3(b`>(R@Z)+EN4Z9=D;7@z#UmVzp)hh zW9MhDyv$^UcE;}lUq$;3lO3rKqYolZoJtv&&INe2^sZqi?+gaP1%$wO24Zw5g}6`! zb{gE>uu;4sW7Aq}gPn1Hm=a$1{&pW2#9>sBF2Om(tnnaTMNb*yt)CaJ{gyNHF!~vA zp}tcPheoYGSlv`eJ23(W`DvnI2v`?kzkivsO_?haGDbq7A{iQF3JD=&ks-~7 z%8+d+ibTdj6v<3zKr%E*Wy)BZ4cSfRx%ac|eLvIxdEV#$zV~tLpai3uHef%wrxw|&EI5x-jJ+=LxN&s4O$1(^}9LD&Q61iCmpe>y}2|}5H!w#LSh}` z0NOIZ^`5z7hwT>^z{UhWhkA8RXinu6j;)bhF!|K9WPoa|BsO0635VA&ZZfTN!#=gt zELKnmM|%6NIcMhXWwZ* z;J}GCHLGcR`ht*Gzj0$3qjWtZBY^wUo3?CehJQ7zqh;~T`}L4dWF}6+?y$p{y85(yjXVacuvoy4u>CsH7$mWw zxG2Xq&b1>z?#tJ&)hz17D=XX@sOpB5b&RW43a81`v?CMqh?p@KB>SE>-s&HNF zn649#KkIL@_+-7==WJWLwu~PeJI&~JoPmz**$(v3A0lY*BGyYMJC<8|3@Yq;>CVfG z2mh^kR=y0>EcMaMnKK*MZp!WQyDToS$ar|Pv74HzAs4PXFuW*Bz3tznouc4U`_}$x z`$xAelH!|qJC|nHA4tXQ%bUp~x^G{)XUtL0ReHQk?hJN+S2A+)N!#lT!`blEX<0?b z3QB#zHe2Ti&{DwP>47VQbx!bqTK2Hp1KSOC9_EFjr-ZH zy2zZ2eWYq*S}(Q7k-VV4UR(`5d$tc~W%#D%UAj-dq|<-V!=%j2@}tw6sV{x~=FJ~N zFF8H+eOnk5vQ)iA3sYQ6f)(ph@N-G+6Yv@tOCf%4v8Kv@zxi{LMLE~o)@s_SRo!iK z$~6airhQ#y@cj4~v(uxWcKiI-Q&XOnrn@Ij0|WpZ8onWIXV2Xpfj9H=+Nr3haP`Dg zatr6OleTucy3K&Z>_XSs@LV1qow|0d=L@%y@zm73q@p{OS5W_Ats0;vCnRyC=T^#sy>?y7d`oyH*SI%OQ&f~9sbN@*Sl+5 z4k|a%P|OBhBz;_a>_W!%5$5K>+qMnm=#YSqeTzuz#o7AysXT*Ax2bru@+`QUuTGXQ(Dpsod{8xyCQN*#rB^9$;^tic32gzzQfPyl+}KR7 z-csF0aP%%L$|*alzjos328x=~YHXSZIY+8bzM8+bX>jV^d)??p9miel?>~de?3uHx zF=TaE>t53$%NAQSZqsvG-MV$pEz0Rp_V~=fvP6B#VsdcpD#~y_j*4+yixysWj{LO) z(#4){uQAyB;n#0iegL{nBtI|#qK@?$i_*fv!Y~Ex6GQIO(`7S9#lXOT!uczQK?ntM zxwo%lx9u0DP7dl-T(pKlM!pI^?EdSA*XtUg3`}-_2s*6ihF%%C$P!Pm}9@b~c0^9Y4M) z!88JLBrBnRXy*F$>#GRswZ;>N1yb+czdJ1g0*!e3^6fq3GJkM+$p0 z`Lta+751u(4k70@Y|eA;2HuRWw`uyn4qVLYQLq3AbyREe(ox_GMcA6U=L z%*`i+4^<-8q)4lL#?w|QndTCy?Be>kxw$2MoV{~$a@s?nE9-(` zzxIzo8F2*utWckv!_>w*h`Yrf&bAWx_o}jRF zTWjm)tXS87*dm<$B`uZ#o6Petv)d>foC5_Nh%I)s3rad+vET2bkb9HF2d8Ws+x; z=8K2>rezvw2#V+If-rVMeadF1wwK)l(MW3Y1$nx1b@<_k2$wbmeY_7&h!q$I3mbi- z?eWpUp)pULxN{%~-b})xa1#_@`_E8~Jpe)a;gA%#Gm#?7^Klp$PA;sHna{wfW+YP1 zhvD)H4N?h3H>cv&$|fhgTc+DSGl^&Z84*aG^2QueARW2^M)4?!UN|3Wk_Y@<8>J=@ zCIIK93?~`^o@Rh@AwW8rG(%Z(j*lq#wmFs8ShwGV5hXJxApL1hr^I-LyQep={DRZd z?NG<^4L?=nWlWj13hdSsI#Z@T!Buy?S^4Dh^4Wit^>y7F zQY>L5J4a2qS+#c-i(LKjWAgl%IRirBP*j+ETL}4gDOj1pn_ zrx6idA*ut?9p(~F!i>GPQ@ALNXP>v}x4`$>wISi&E#uX9q_59&e)V5?C*c(1x7(+0 z@4}5nwIHD#$Ys>)+ofsdnG-!^xWL!*ANjDl-CPg?{cCVnQE~4sa*Uhg~&K6 zLsffdEk{FfgT`X^4P;=gEo}{suKfD$R!YiwUPKd3<22g#ZZpaF*wmP=nwpyGtFzgX zTy--jeD=9>K5{&K(84bp|!Cpz*-Mc-t zeFW9+o5TmsvBhuRjD#FeVh5de!ZaJ+o-J#T>NvNv6fHI&Z*7T;^N2W>hAq& zZLu(n0Q4&)T17@i+7w#EJpF6sEcSqu%uq80)Y&1rGxk{@88so!bu&pEd9Rh%)C6vX^~qPnYx2;e~$Z}e0j-y1xGS4 zTTJ=xhRtdF_2y4ll9#ZP8``KYDs$h}3Fn+iV1$$Jv+|28jZZ@XX!kb=@pbRsy%jz_ z7>}nXMlGv+tLn7RK+HaFS{=CkoRoK;46fpnt_k{I}Iv3#?IZnzK z=7w3$Pfkug=bSf?`tP;~OIRL9I+m*qQE6{-2mEu^R>vtfE*Lr^I4msisnbjLd=!T+ z`qFZtKHYv@rd-Wx8bjWGIo#Bg1=jB}DkPl!u85v&)xScCihd052G$%k!th|!(Uk|A z6?LDLXiNwn_c=CDQ%B1nmPt{cD)YyIzqBVEZ@Dc&cgvdHJ*RAiqHF=OF1V7|A90y% zPV=yv$@`IG#@u@F;K5hTu@9TYfBx{n#!Rze6TjMVtCieA5(VG3-zPD8n#5Vf-#JC~ zPE6u`weW?l)thsp4q3TiWl)~8vg-?{*Y$>%RLHAh>7p9U?A)!}MD`O`DvSnoO3q{} z%_cNOYX;u@7`mAO+coxN+pO{}AI^>~c~mjtV9Q{iO6PA5lp*q+h?$2tFj>zY^*@<* zDu;uQbGMq&9ZEG>78h)F2%c3;A@l&)-rm(KgK3EA`1wVClbx*){F%A0f6~W&9*7{f zcLoqM9uPL5n)I|GsejWbppm6bT1Pc;2l|Gs*N>uXMA{_WzYh8(jWmV|Bjz*o3}iS;taC3b(XfWnosaH9h!J?alrUeJ$Jv z>FI4JI>DFKY-76?6&DLeWfvIN{CFR2V*g`S1Q8shj@;2CF0sy1xe+Ya%G^w^Tg25Q zzeege03MXYt-J0>{~CVBa!qP-GDCpdE~|Vo7CG@jW*@7|L2ee`+XPrHDnlNQ`hKsQ zc}dp1e*QjGMvzr0+~F2Y{G=Pj&7@B3v{QfOUpq)k$~njqsJ}1Z-R>lvZNCOiT6arp zFUqoiP!Kdgy`hA-%4;Tj-;JZ z|M?dX3wTJyA5yqfCy9oeuS{bfLL?qi^CKpv+wgCTXXPAB%Y)+0Ujb9G|3u;uhldq> z9vzmdY|Le!QUi03oi;D|b=QBRzr#YdbIj8__;i^E-V3BMkLhJ~sA1rRw(r>Sm5;e! zUcF0i(mwZ%)i8tVdJgp=Nqq`lX>H#LKI0ctuFZz|6JCTtZ3jVp1xR+eLHE=;U$WI9 zB+{jMod|24*$2`;#$%(~v$Gp-wAC_*GSPnLnlNh>nz^0DI!kWEyEXTm5E=R?Yt;Ux z?(TX#9_1@rcr@iC9F4?JT-1g`LO-#hHmvA5+xr^~II-}OuZY%CG2b~bI25jQkYj@( z&;Tnj-9J1vUDY={yaTbU*0$qk{@k@rHGYQ0kPK4Kh6b%_IbRtioEH&%Pv%RT%D(kB zE=QLIRZ3Ytnv|vJ2Nt?nRqx02%PBq}>IQZymN%}o_zk=%3ivUvB%RpR0hrM;9P~te zLlKN~FKxh3(>BN}}wp2l>8sqUby{RgGit8C8V1kizvf$~D-s6h1;;8qmukN~oT>#FIU3DAB) z-y+i@A}HBWn>Q0@SQ_ibhTvt=iQHN#aD)@q&BWwI@(7*n7pWxVmS0hYBq-l&IeL|K$-UVh z?z3V_ZyevY9sG{gv9KX)GbI%zrzGu5hhymvGY(YW04~QbHI(IDZ(SPC1&9OI+ zncD9>j#R7kxKexKqj_V-G-}+Y-*_k#r3Wo0HA{C73<#pWI){d+)v1$YDezsr)3XXV zNmN60#c82nHSad=fCF<4PENbHnNxe@TVjZ|js5r@Mn+TDS!*p%a*pNkrb0E6laE4< z&^E6k)i7Y}E@V7tfEM$H3>WG|{+iZO0VK;M4XKiKg z2U(NHJpUZHx^1ggaBW8kZ&@bVTFbkZw(h1ra{6wA2EDm-yeTh=H)p+Jhk0jvIC)Sx z7kbuFIQn;r0clr#_;Bmy&DvtL=}=A8X~y?vlK*@Lxh7qEKG5HC5$ran#J$9l9TwK} z`n-+z^tbeyh-peG?8LC6Co{-EitZn}zf-)4KJM>e1j$bY$F)K;1YL3K66$W0$Hudv zp`q^&qY)Udq;qj^o3L8t<8-!9O{x2fBGA=PgZ>0R;x^NUhA3WX9y_@Dn>GbsigPR@ z9gSg!S7cm|<^l>u%?q5InX(KkWf?S66xAdeBPwi0ES2&pNgtJ;#kLtbAn~Syo>XnW zzUSA}s$xL)i6NVFJ4RG!H1Uf$sDABoo>I>UUFOodpe9?8y{q28zdS@)XZr@*QyrRC z$0!ub97mcBvzd&{aFfj|whW99gIygvHnDHG6Ka|5S*p=_>y|A?$f7IpP7M8)Q`f9y zpnb9dt`s;e$zNQ{(Gk3BU=TZ~fk~GxU6e$O6RN|-cK5zxo!%83duG;oG-q1;Mtn{) z)KoYI-ioKLeM7_Eix9!~JG(CWSeEmqUX)o$*51td{B3ST9Sp=TphS^bDoNK2UZ#w- zpps@1+SXxU%kus!{j;B-P?z+b@h=%CE`qgAJk`8su7 zx`P&#Ka{D`U7R3vK%MfeY!N&?=6N}X7v)gRctsyjiG-B7Of^EY%X`$}%!KEM4jrOB zrkmmdhnO6c|0+V&>q3`q-Sk1Yh{+@QBGkV`y|S&Q8YzoB5)%`3z(_eA+-~nQAU2N_ zvU5P_IqLq3yioEfk?uNp{53-dj`BD9M^kaSt}@R-W)>7gsx=)7*^<6p%4HH_dT=LY z7>7E_$}w^r&oOpTz?+=1bM@Cc|GtBWS@N$czup9!v3z_v$j%bqGD)u z=#Zpd(x={Ga)a8sNz6r!A|L2XJ-?p96%R=^eAxmb6cJPXwBF8T84=WajDqt4YLB9r zfts3=@OhKvB9yd2crQ{@Q~h8#4l-7}ZUIY%wQGf!SF;u^ZpOJ4_p{X5{zpp8KIF;& z>;cJc=Vw@uzeGX%p==At<~Nu0t!HdDUV*}Hxy#-zyiUD(;(22=l#>vq>Z_*WMWOB4*-9V*&(ekd4u1&bYA?%n zle71gK_a86W2K^oun~(#){%%QXaGF5p=-g=24i`lpVLMybYO#@0z<2 ziuF8+h?6=3xru9|+F^P_MQj@v)6_4|IrYJV9h_Nk#&9wA$XcTNpPYHM&E-5R@I9AF z>VpZg+HEileEay;Ei(l)6?yg$#m%!U%aV@a{cX%UXTZzfB!mwLWdLApA{`SFKJDFM&!cfeEaJ+m|DTJ{MTxAu61s{f99SPuWT zqwKv@frJH-Q$@VwaXupNSX>+D1Q~|@tpFKQ2 zsUaBem5;UHfR}+ohxe?6@h`?qKDlJ zzLh9C-ExZ=AM#JZdG~f(t>tjSd&m(yp(zz=_51go03nceMB0f>qjADLEkNJVl}L+)cL{8J>=qY zRb6+L$dfUkN_zH2+Ss&Y=%Nm(wv;(Uw*UlZHCdD__P3gzgMUWWu+AqWOs;?$G1j1E zvgY2kHEU3?hJl?&jv93%FE4MZkNCNWPYUp=!Of;4R;-Bg*w!$vboMTPhdakEljNGW zY9(}EAAAkh?O}L}ii#LY*cc<<(FOMot8X-9u%Zf#l_^F5@tr9^JGrOnoo}*TO|5=zT&4QKd;*cU*M!Ko3DVl@_U*$$+!#YKJ%$aN6PM_n0!o~E z$w?hN@evUXpPmVXSm|l@~n3gb{~*V5~BUu$xiD6;g*JOO2PF|e%jyx!|W{S2Kww=DW? z;vV;L(2Us4xtb9(!G>>mI$EVcuvK35*k&h36{0;Cvu zW!cT9e*XMYT@?*O(a7ZOz{%rs(ge(dO&Ud3EH!B0CJs5U$Wd%AX;sMzr>5l~ zl)n2Cx8u5Yv-oSj&oMFd^X>_QBx%5=U3@*hU4f2^Qb-B}UC(+d$~@M48&jK6usy3h@B zK}PXkK>+U};68K>-&oghT5#&vdSlY?vGVCfk4~nu z)s!f|u2GdPm*ni2t%+WIi|Sg44uRV!S~v04d@P$J<_x;x@2`3^_Z)Gv(< z8^Udlhxqv3x%A^A#4I_RM1Xp;(XfRmp&vIx{RO!iDMCxdvbrdF;nVY7=;j_^VqzjL zIHn;eRZ&L?hpXEDkbiEIQ=;+h4ABqlHg=yG>5tlAY4wCn#s}_a_0hytiY4%nWw4f@ zT^S&$Ycd@BwxA4C%9|IXrcOj>j3CpA`x%%qFuw(gGoczO;Sd#)BtS~i9W1zKe%;5) zXCa0y2}w%52K9397TB~J>-%+Wm6^FkEFk1CW=bj)RMrh9Z*sW5|MZnT z%erjkg~h--D7afLv{E(r`)Coo{&MgvKGe2;v&WW$40EE!wHK3O;*WQuRom}PE0z+j z@DP?^7qyEr_KUg(9z-9%yw3DXjmRqO513RuHFNFlQT>z=)?*vFMXr2uYNqyfqm=%R z&@e2$BpS&Aw+Co1UW7paXKE=?$Kabwv-Cap9$@Sl$1y{CypD80JG)lSTZ8X9L($x8 zxbcBL07W>US}g4ZjC7rdOFRh85CO?WKk~{SJ%A#xy|ADeh(JqMx5@Zpqe>S@b& zi_Fu{Ep&Z7-29e#;5>t|U0Z-iWo}=VvfIAv-HX}?08#+}`A}pu!=eb76Mqi^WGAdA zh8kOKR_S8%H}-m0MNoc^eB4w+;|@B25|r=#CJxb4Hal#6>eQ7)$c~aZ;vNv?0ME5+ zltTg!f_IfgKoh@52lCC|#7yjbyTuh00X5mM_VV4yz<+r4X{w_oc#R&u}}Cm+|1iYu9{_?mHW;w8FDv z6OKAIk^84^b<|q^@*fP&@sOqu4qaNPLGP-{0p_s{+@K@>Y~E#5T*(*n^9^>S-{O-I zR)tG~jwr0C$P)3?wLl?c95*K$oa+A{#M1?sX{AgIA2v7mj=P}-1ThYID;OI~OG`xu zJ-z0>(q@lM@lRYdxqa;B8K+LY>fN70sO|-=t!WV!(~tS5nWnGsoqur}n~|~x_jWqr z=KbL1K8Fq+>1STixO`{#cLfr}2L2A(QUS_8LWnx(^(E|LC{T$!Jt@L(=9Lxq)Qdz5 z!7y-$JSf=uT|cw)fz$+IaRo*Nph^*8OGS3c%-a+dt5~ zq&^T>Br>imnuxH$QRA^1gMN;(4EtPim7IPdN zI?Ik-ub(522gJ=KFQH3K$H%qiP4xhT%_&33lnXWt2n@dey) z8ldm}VS$JOG?$IurBjH>Yjmq3%gfFEo;uBkhLq1?kcE{JMpY5PN%~&Y9!zcM^V_Hj z+-})(av{DH`NO4fg(^@XYH$I8BUQ`gSrdm`&HNUGvCj;ft~8 zE`xPNQeu3K#6%uxlxor0=jCQ2MiiHqXEK)|0%uVt%bxHNrpa-Z!nq+xcQ!H6^d%P> z)ikbxyc3~ar}gNg?fs*!jOS{ErV<9JrS0KY_AS(LubtANiix&U$$o+aNEjhHQ=6|@ zQ{!XOeJPy?*uIbNYdKPKMq#9YveD{`!c0~TWWr7dUEQr@h+^z(tl`?gDMkLcs7Q#E zfYcdDs)EI7WG&>RR6Z%+(5xI@2!ri7Rf167d>WByX|c{a-o11#{)K7I6HB^6 z@C(8q+l%8DR3ti!$PIYcQE@o1yLk4ASG||QGV6c*xp1)uyF`JJwBW$O0L#hY|Kf){ z)vot|B7_)K;#SHw;KW+48x8L}M{WOo8m(?mJMlNdn@y=82+!w}ldosTtrs3&Y~p7M zrosWxGmE$PAH*Ib?+@Kkt46je=u?K9X?)E5u~>IT5}L&XPKgWGGy#K$=eirB0Gs?* zM9wR&BWZtW)V$GkwIQ|c>Pfs+n%ZeLsM9`CV9;9!? z=ldt7^e*r||Ildw6}vFDWB2vD4%Fe&v6z)#-K9eSF9A5!z5U;kiSVxf5VJT@vcG!c z0ECQE<)=Cs8L7iLgB_iHTzf=3lbNqb8&OnupG(8cH2eRKaX^9*<8a%dn+`P9VAo(L zU8opUq7+YcbNidksm;0jZWbmv4T!<>!5u7^0jDUQ#JaS1y}FgLQU)}{j6{stfAI1I z|C{x@2eliti&SvAgkP{!`|Wv@1=0LaqOV-Nx_^kll4oXO^ZS_4c7q{KSGkhLi~G!4 zI<-u%)$(%lX1n!6Gl@kT2ou7|k*Bq>5WD zq);twDX4#Qv`Z}fYloBn1=8{~qL~Xd%=VliMV+esHZ^vfXi3y$g4y9VxAO*9q0?waSl!i6RLma{L6)PM+9q`ui)lJzyhA0_Ubd!eCr)C zs|X<<;oy`c4)2EvN@AUL_NV2B8dQEeq2=c-avgOMTq}D-RrbiNXH7>y>>`{w5U{fn zNw`*Q8)+t>dKX+l>M1Vj)Y9vNTK~FdabH=58On`ig76W=Q}go=f_*ko^trvfqt5zd zK>|6e7uixrQcl+W)p$TaTDg9$8Zxct>5?yGrapAfNfkhlB}gL2^%l<=4k*LC<=98r z(7Pcr?vwUZ!?yV6s>sL$(?j^_q)g;ON-uLbG z*tGqZ!5@N7q^Ra~g>f~QQH)k;Vt$J0rNDYoaKVS4(X1kPK$mrxYI?ir2+VSTrH(X9 zG6wr`@`$eQR*Y&}^!j;hZ}EJhSN~l(4GbO;aITap^t(8yut*^vZ6<5hetgDg$$+-d z%45O|gSm-n6NZa{v8^~fwOwcK=-RDY)U?LdX3kl06<0jpG{-tm-7LZA)u^q%HO2YD zElOpZ=j_O_)3J-I+SPHZ$PAAUs&7h*7?(H6Ow+JG%ev7nx6s&ja9_$htWYBb>#@MS2asHtG|RK&w}bhw7^rA1BCI}_PmUHjm*btG|MYYkDIxkBm7=b3lo z>XpB^`h5wU%%^;}QWQv+Gp)(S;gz z?c1xi`ajL}9HA&7qp0=GL4~xt+Z+yRyMArI{d`UW?tc>Op2Bgz@qD5=5Ou+OAe=NS-ZVq_Datuz3@sukk2@yL2T&dTa2W)LnhTT9PN zQ(A;5+T9Scs7Lz1j*_*_aOoy|hArKSZ3B5eVwiStzkkEbK_SBee6&kX7G2N}H1F(D zVZQ(9DO2%+oFPg`t2JSYCo|&}OWuw<)ijlZlnRFu&m~Pg$C-A{z@l@A4%(33vknlP zQ0=CYfvN8~xzjfaE06@aZ@8i=oS!z+RO~2To%faA{h?rgcFikMkWbs~Nxc}fB2sp}THY=Fh>F2~GEQrMnI5?7djO=~vu zH2b_*Q?u&TVzP?Ae|@Igr_*LF&KaBm9NRyo)NP-cW=l=eF7hz zotr2pV!ePwX^8Y+$NKT{>b>k(6fCLE#}JP(*K7V1ePjPW`YgQPS?IzftO#J&1B`X03DRqTA%s?1M>n1Hv$Q*uqX8b>e7-l!O-n{+MeHSeO z01JV|%bXZ#*$jX|jZ-sN#f8AX2mYvsLznG;X!{gl{-iam9x?vmnOW^AKteYf66++N zAO|mdS{>lff1#-cqFLu2JvK{cI<`q^TOSzvDWm(XzMM6x_g!U1+x#8IO6sWXXyyeI`ZAo;mkv!_+i!oE2npVEh8_*;tDl{f zqb|6d`&;!E^}{aXwU_kQ;9q4k)!x=?`hZv0l(=xH9g0wy-Rgn*>r%CSO2db(`||bG z!G(`bs&h*3&pu~a&-&3kLI-`3bx*r^%#D2>&0F(u{bIGa`@9(x(4p+zYV?6BNaXyO z_f5StBCjNd{pZTy)c7v{b7k=1o)Le|KVa;2jKK=612&)yY(a^sZTQ)) z4%)OmlXtOdg-}?Dj>duXe7>l+;ndKXLV8VSj#+&<><|lE^PI;`*`ZxIv0W3t10Vez++-$8MZ->c z`?qcLjg4Ktu`+!@cGdG4T@zVHLZB*Ak@7Mtt*L7#gd!jF71l#{M0pQ}exnnj3iGQvsLnqvfzS4EJQd%izcu9rT%@cY8hjvMmRjOu|l=!5S+ za*(7Xfw;@|$R0cbI+hOqdcg76k3ZFO=1CXWkTr=IDRpz5x@`Rqy2tK8Q#TQv+wXhP zN$WFK4}qKg7T#Zv17-df%}(ZJuU@4RB-6=oG8~28M)j;d&i4-2<*gdIu8RKx$+%J6AzkOhSHe}APeY#tMGQLzy%unzmh=W*LTRU&dpVYqu z=Z@qxsbb&FM5|pz2(JDw(5n?d|FmOO-NGd(v?QZa5;&B`8ef<{Rpug?U$y5X&0^#;g#ziRP4aIFn z)hg}Xo7ywaLjlq9ikNGU{V+?p_C}E1AY3+?p{YQf{VEU5OCFK4P+&cEwFhH9p?FG# z`7h5ky#g;UAr~Y@I_v#=`o#C7tO8aa?T`NIxf{;}q-_zpFie)H36(D8z4X;cA0qMz zhcP8DZ$DfKq|otRez-gSbNQ9m@7A%Zjg~Lfl}a$`G*wsMgjx>DPx?51C+&1uEl(qS z@b)uo{7si?yVo3P?8X^YA2)8CH01Cq?0j6cf(``^mz$g#QE<-%)c{CS(Vw(VA7<8H zuBt2~yH{HA#C5|P%ky--JwIl`#YK~3tVHtMj^ue6Wh*HE`DMe>0vmYcPjgzP*MZta zc<(;*iXqN)wqTtTIkyAV^%uOjLg)9_Zop!RJ1uo=W&89szG4UBLEo%ws zKuEc|u#p8l>rWs`H+F1-M`RtMSu-^?OF}MSq=eZgORIxLnAvD39tXTW$8d%c^iBo@ zS((|HkK1Nek{CVyP%Um$lBpf&m^DY&O{85Ip#t_qn-K!MIGiwlLKMyW;(MB+NIY|} zSG6O3Y<0B^=nI;9eDbNyIg64DU4@-ue#cl?FG}kox}=gZP(das1ck7!^>SCJm$e;i zsT$n&Uy#>W!@6E`YMFnpu~wbtJ{BPZ>BZ&y`{;o9S!roD_kb9rFvnH`XMMz{a?5ZH z9;_7TKIUSNoy3ppqt%Ph1lm$`*R?b-8fvB)c%kD~Ao4ru^O}}Ep~UToY=tR=r+)0F z%Wn!oXkpf^Tn&#(u)hf@CS4Hl#|A$tAfjqN?mhQ{YM7;W%7$wbX8j%~wU#aq_<}C* zJUTP4?7`44q!qC67%PdAcZhxEgt3|m0Z+QfdsGH)rEid*NLHtRE6jb$`u;DKmFxFD z_S;s_V$r5^>-f6%Nw1L;vhtO7a+oT4`haAZo5xbcmIUKe`$W#ZGNokzcr~G}r6HbNTg19$Ww%{-hfik) ziOhTeD|R0rK6K-nO2W}RG)l(iOvJrxfUAT@X$b1rt8ch7ENl!JSxlvzrH%s!?n417 zqOARYDLN8brYHTJHlgplyR#0h3BK&nyR6@mc4b~$5%O|+YpIw$yBdjVBvnyT`C($iI;}Ikz1advD|ZU+b4a@(IeV3*C4R{kOL(0^MGp_b5>Lp+wya^&^b>u{Y(8!pa!@ZIjR!OJg~r=RLt$KP_%!YQZw zMqXKVbvm{ovoTGU`1jIM8BZucY$#wj&6h7t*dC4Cpt0>z;DExhh_zQ7%Erog$Sp?pjntP>Cr(20;_vg%tEF#H`AXhIo{5N&0P zZIvz737Zf&%!4!CgB}cl8y`d}R%1#ou&^vZOufXw-FmD~+l z>!A9Ex|N?_bKs=Ij`O;7 zr;Nb>+}~|PN#96fnXxOHToih`q%`XG*?N1W^d-M=?NhtEznry}XB;~Ob4q`75=~yV z{5r~D{K5}N98!tn4O1K7qy{RG&R8xd6Nk6sqFfYSdXxd?ioqXRdo?AoR}2xLIO29M z8+z-rSQVE+x0IxHNKUC3eBK<{%|)0hikyhFyguI?*m4XocMy&cX#_cT4=^>-yE1R1 zq34XA+i_#vxN+kPPT);JLCPJ#Sy^jpi$g*Rrhw$_$EUp58nVhA#pnm+iOfZ!8E4^H z+s?J2g#S@K9>*H}t$fIQfF6@iu1M`4a$c9vmWi(Th5fMtCZzJI7e@GDLU4u$25iIS zhPl&!^JXnvxiZ9wQ+mWZ$lt;0w(_i$vF5k)8DHxNj!bvdl)S&9~v=9CH=bxz3GEE5-R8(5J^!d-;rQf*?Kp!Aw2KE;RBZuf}epJ_Y zY0vPv(GL56Y9|Wm!vSALVU%KXIF?=3KR#MIhpgdueSEaE-rbd{ubOe8gL5CPa|ynq zuX#y*i2dBTSav&;qTjq|%Wk2=TDZ`@efz@8Vd5Lh_F+ifOUC!lA-{fhNFUNHUZ0ct zc^4-&qR@G`20$?q-W0h@%mLdc=>K0-GaF2Jfy{t1poPr%Ysn7TAAs=B!wzn>+$E#( zXye<6R~3Jb<;Q3E25e)U+mT$fnAHG07GAEyst!F*1=ic-QF=QWCdhh;YIm)g^S_YBFzrE@9?9vjs#4+rQ3+bFiccYbEq=JH3#xX zJu%g`S1O@aqBpk%NIC^a%3#OICvv`ON}FyKY)S3MQ%cnErUKzr{t7cYUyFuV5)G44 z>z&U2Rte65Sndz8ppda0GISHVfj>&dnSg8MbR%*oBLi=!zp(tC;GesPDiv1(WYR%M zaOoXo$PU9`5O&mwX^S>QlkFzr%aguc$Oc}CLHSyebh>fzw~K^rxFf!Z_`HT5AHS0> zKB5!%+-&9DG^g8}wZ)IfMt-v~|4c&5;I{V~XlS{QUbs8_YL4|vt#<|M{rn!#Q32z* z@Zqs$V)iP)F(-qm(7XyuOOv_i?>61}+5)LEM)7(=(QQyA)j2dT|I}~h5=+9-eVhx@d;LjWs|*`Cv)Vc{sE1;fN5y=(YoU(r~U7Kmix zr?ULCMhC6f*0_LRB(l&4SI`P3$~12~5^YOddoU%JK&54BSYSN{^n8>Pc`&YZkj z8NzwQ=gd8o2d8h{gO#Df^}y+^lXh#l>kGT$oR+p+UF9tE8hH27&UY#Y)SiE*DsD=C zx9zR+7CgEyk)HbqgJP(WvGtn9yc4BS3t)F`3~@P{|}o-cEr zI>@vClPg{xuSRJ=C8HQSSc7+EYtUxSHf2i)X@;TuLs?D$HBC#ZQZBbv?9q2@B6vEf z@wyE8Ycp9!I{g9y?8(LIiI3w9phisuSIj-_E#{X2j+O9)AbbNGjsLi~IkJ(uo{SKc!E+Qcsa!r8&5S!zHsrvd*bXho zfd5++XZUttuLwsBjJ7Or?Cf0Sng3N8O2VaMh*f6e!EygbCAY6TefPoBW#Gd7k(XzE zLE#YSEQV)Ho+7Tm9lv8XP_4-6bH6Q%)Cegl$NX%}Xr+o(6O zQW8ZRi^S13wlUhJuD&$5Zt9xk>QRHzb15Cl9xAfY=E)Vzb*1diU@t@+&GAF zdWbwal(9zA*-w-0UB(7uZgTmO2dAn0tMRnWY1aaettvJjm#S!-wcB7OBmXjF(>KniXQ1YrjaPW#|dWd94Ep)ZLkB5NDfynv{^%|nuB zqv~xkcg9i`GcTjHKq5z1I@0z+T1h`NEcI}#xiWL2m#GG|^&Fafz`yD7U1pEspx9Gt zg5~jsb#6DA|x#W-7qU(k#TfT4_yom4IktmT(;>fhoV(L zvir@@M!~6>Jh8}SjH0N8t!oY;Ai7>upx-^5-$~ap;-Y4ZdKNcF#x^3>axO*uX6t;J zJO@4i`_idY{H=z51F53@~T5#Y< zhY~SYCfW>e&P}6jA?&L3W7wRTxt~`SgXM-^I3aQQQuB&#Z4%=t>`#GrI}0x&(O#Y60ZIl>HuZR4#!%%Yf8mkyjq;{*IZxlYc<3B=9OK(cr7&TR4F5N5on6u zyh+D8cpZ0)qJI7QNx!|)#9D`pU5$N(kl?B4W+dpSXSLBK-@JJ7g0_8!xNgVs>3kg7 z>@j6|dYi!C^VgnUTQdX-S`e3rgrNKu&6^jkEGU2VYIj*o>i|v1O}U#$5bvS?o8yuN z+pxSx=!lm=sv-%>_)O^f7ECbwnZ{_T?3k#G)lKhfi^J@eylK)PXjKmkAcyoF=6>asWPm`~1&iymp;Re28 zVvingR01erfEc>@ed4|B>};=}i`E-b>X`CJddQN2Z>K~g)~;1+1rogIb2Z(%X$5JF z9oe*5w@!suaXE`wk%&EUMy`wilo4cfYcTdJ4Vln)diH9)1>;ARe451QRYnI@0}ebu z(l4_QR))=Sva7lVvy2&c4;}_-oxwM^&-o9ph||n+fN;b3N(+XayOmbZK&d|c#4}JO zA&Ez4wZ!`_Dw9fr9e3Yhrl zlS$`D2qIaSbG((*R}6w^&v(pPjn`lqcp-~=US@Qy{m|2HQ`#w-mt{tes4943o-kq= z6Og_1QB5ww5w*di%T`fLXukydii=kqe*DQ1ScRmI-eWE|*y$Fet!3bt+ikV9fzzIZ zGF8o0SS>J0l&!MxFJ3meD9xV^gI~Q6yy-{aUXX5`S|u=w6>lJ87Tgk-F(DSOQ>8`sCO7G{SI^HY6&jmn1wMvgO3+F7V}V-wHIG;0p1mLgn+enm21U4DvvRwi2@H zShh-R9{haAdFQ~zQ+aDb*x=zvN9vI|n{?n}!o5erkiK3zs3n`C5WfOzLw4ce*uU;J zGqT-QU#sV5u9to62+3DWGRhPW*kj(iW6{`l) zS(RAx%SULf3LlZ(y;8=?SZ!o7|9@il39V1Xv5Jb(VepEHe?N<)P zR3@`*p$I!+GN6Cg=8#IKTNCKE!)Gik1XBQ9)4%##K8hG?YOZOTVzM~pfPaehgOssx z=R6-%Z^$qz!d)p(`ljBIz|!cT_CvDhX^dO>Rgc~pk?{|!e^ig41vnaNla6nN=z@|-rZSWrgM9}EoQWhPx*|`x9n(X> zw=u<}CTnUU8M)1pZQ8u~2Cek#wqnz}o}Zte?AZ0)>%L`uJ9boZajEn?6Gi(TJSsji z?2qD^zH#&BO|K=-sM7%rVu!^Cp!k<;>phcT#*_<8=3`Nn7+=tpx))+%0(jQ3rY*{y z^e>Xyg%-tcFtA%KHG09+^yfE%yg`kmO=_m<{$PKH{$2eZZEWSG12mKImROQ}*C+?_ zS1d3ng2$P1r0OdI2=;qK!)>*A+jT6rYc>E8#w0z2a347aj( zh#*YSL`$mG2SK0WtN8c>T0@sGod*>}Pf9B2nnwBd51n!E&^sV4V&XuAKaFbWroi5| z4LeP9!I1YT9yb`8>B*cbAV2$Q|Fxck10dr-GK7e|j586YS1=uFb*kiNySTIZdv@NZ z%9FwBLs2{Z9dMh03xj}WNLgtdg#O@~+*Lu8r z`vE-c3d+r_(gKhxunC0L2EZlEB16W5D=JlZ704>vc*DqM;)|M&g+Ppt@IX>|GOU1O ztIUT;_X5u(vY1#>f&Kgcr~=5~U)f{eqKVWX)H?mF0c5d>_?U)r?9_#(ynwyNpP8%F z6VQlV>3f#lcX`{Y(4T zSugB8n;8JTsPs}<0kKCnM3xjU2`j&Ez!G6i_Mh?c^125HAk(5`n=tzB_tZ(dSzTXn z))@IH^q~Tih;^^>sM08NJ()=GTKYB(BisFzbIDXo<aW{9&xplJax?KqU^%R@O!Uh7thR0(5JzYws{W(juKMRD{=+B8U~K}A__cuonSE}} z(c23nEK3Iwcor-|F#1Yn#2eR!78;A=ZP++Qidn0_cKI)~0$Ai99ap{tk6{T(Azlrc zev1Jepe=56LJ`L4>y6L&y! zJx<`37?@9Rnq0dhb1KJ~eC-TC;QaSp{7C0t?ReXMb^Oz9oy)~(54t3qcfN`rM+O{0 zyY1x=A^NUNC|6V9;YdC^=O(0LI89x0nE_q@V4<+e$F&CpKbM(45_jBAT^QE*w|CC6 z)$A+J`;2(@%m&-qEC^(Q^ycj@ z1%EfE^+!jybc2u3?Yu?4ghF-(L99)OoTOkkdreLyHM-ED;GF2h#}0ah#l@xsYffT4 zXOp(322HhMr57KsLNU`PsA05cCH`ofFEjrWJm1t3JB-Y5Am8j;+Ht##J_u?pbx_}L z`QTbFu=z?TC|AI>zwuFeMp$ok}p2aVB({ z(lbX#ByKZ6lrVa#2lx6rEG>JjH8qUdh}Pe2z<(}Nv70sRJ@LI>lBDy(xpv#A7qk|-0{E}t5vUChpUBt2dftV%Kj)%9wkHJy4SX>pVhmw;YE zA+VQawv=P$KND`I3F!jcO+OD_pa{;xN@^~my$6Cya7 zX3xcVN7i>`1eoX+62d_;dvHq+2+j1GvFPEZb8WWXYy04nB^!=I$;*RwZNY3^p`UOW ztQ*`hIQ1@ujZ8*Yh`W_R4N-8a432*8b?}X=A(gTW;bKS#aPt_IqW%>uug>3o!Y)QS zGW&>%m_#z4uO}C|Ktj2LtsN^*PCnH}>~8claUq9{fQ6+o2iVBiAfTp))objWbk_*g zP}28M^aye)fr87VI28&Ro+XVRykd!q1l42Q!13PVg@c}vqbq!~48W98;VV~O@d)n; zgPB$Ncy%Gt31b)NiIF)m&{`p!=^}*%g56;3<0_i5s$ z7{GWv#e`(p)gnZ*l3e>VQ;sHRfkW7PoN;v>da$jJCJvdmqF9CtB2*{OJ-5JXQE*Lf z+#U%0t#BsE=mW6=VRasQyj*VYsFy^dGDQ}}y8p)e;Jt1QTlH9vXM!CGeKPpVj^m)etA^FirlN&B2@=?hHI)e1v#Hxh6>FgR`tc`E$`q z8-X)2jSx1L_tuvoM$%?NmB03Fwx7%-CZNmp3{u#D=9X9E`Y#?zU#PJK^|w@(46b&> zRo)*vW-mgBjOb^xSVvj48=4Up5ciBFl@H*_x#fE;Ph6|UOvL1){TJ>YYr>BB4cV+A&XC$a%n^Si<)7nKS%o;-Dof>`}R85+GQ} zu>FC6w53EC6=`Rau@J0>T*#5tR5^(=glo}=SX%&TKA%$2fpj>@|K{tp6tprIneuWq zod=kM3ni{x!NSiMRFMo76r{p7k!u4uWVIs`Qd$KMa{O@Z|EpYHY12ZwOu=F*u5Twz zHaDx-byRbcu?03zE4G_LSO9T6pm*T32>{B-JvIg3oC0ygy=uOiJyQro(;egtPY9`H zNqtN?%lNwduT9ZW`h2o$go?^rJxr&h6zEyQqWP=hBNlh~h;^u`>+C-y5HZAy!u4;V zJ+7RCnvraVT??MzP>iO_#XFaWiDD^SbBGwpFsk-hUSUTs@i;zA1}lqK%H(_B;TjezOi!HLoVG4}X{_1# z@C*74CT3mexC* zWx~nFHWOB5yl10%J0k>myP+S#JQ-}eLHmYRxyqus1!SY9lf)^VpJ%-cw#51dc>~n<*V1se8(O00wjbNsl9@ zJ85L3cjkRY?`sMv;i&x(VERa2g{abR;i|I*v}Ql&i3M>R?}mhOHo9`Wf672doy~&c!r|8zr6Fu zPz()1XVHQ_2Q7}v0C(Y1(`g-`|JqQHG2;Eo`C9Md^o%Z;9I)IqC)cSmH-3lQi9<`T z&FIJImizGj9AsD2s>uqhWy^|Txpkm*A}iDnjjDD*Wo0%)kgb0ZNW@i0 zCKkGSFUv>wbT(S5+{OdP<*|Co?a$hD4=%P?<;*P-pjw&K%1wk=&kZnYV-0QZOE1se z$dN5jeQ^d9AO+4rAo+pLN(I&Fj^dLNp$XwyL5{8ytj~0EdMU+C~I&;9`{%a*1Qgu5*)2at0Amgp1h8Loo zK0esuj#}(3_!=t4Yl*nh|HXKWZfna=? z3P>R!i7@ZMkF)Ki+eh8dHQeKE=7r~n#5n$+75--NGCV-X0f;4y4yfgk`x-Yoix?z= z%d0WP49WvqHjLB^8_0U#PQ-635&YGGLe|pDaGqyOM=f zX_LG@+-TW?MjiX<4c>esF6N70>t<$6>!heF-`LkdxmB$v-Tl37+c>@q(`-`Ky^(HO zQLTtPon<`-uIrq6UoU)Z_b0w!#XV`7Q_Z()eXi-ytxGefr3tA`S6(~N`Qg?0rEiB- zU;X^~dv2u*vzyR(WTuw$7VFKW)EY6|R#JbLsU5|a9hZNCC3sjImG==|K|22yBa zznJ^nN=17JqiudLIG|gvUR&5HqB>(`oI-sA#kAZ?vm z>hyRh-|5_Z4nWGzExDDQ>-D#3$AGCxNiJLXR@;L7ZmlpAgP+Z#@r zG|A5U%@HAAEj!>HDy1hI zOLOu}f=XL*^X7|B!x&o$?&@S>a)5;UK4aFe=DvI;M?K5i$>nvIkstRjwcZ}t`$$xj z$V|GI|I*{grXX~u-MQ1bel4I)tF}K(;NpihZQ8_7CKJczEt6YaN=i$EckWC^Ax;A2 z$<(r%PcAhUlP9+(pLOinGaxKXBiy^{`-hQ~H&$*;PKseY(O9Q;J2>k&pueQWsL`X9 zq*;Ba&K0+B%ir!>e0mNEW$4F?l?dH(#p2=(gTwr{Cx-58a|z-2*U$W#{g|l4E5k|t zf7(0usGQSwk3S`ZnPfzRRGKH{?48(5G${=|lA2^x4jHGM<oThNtIu|L*&`zSsBry{`MR z5SirXfU?Tz6DAZim068zzgVwx=f;AZDV9c$i;JaGiuX5iP*>Cb{hw{A{Jp6@w+Y7V zg~uQr9^B-elv&VU>bKF}Ejb8P~g0RuT05TEkn*dK%O_*5_snBsG_2i7F+|Izvvrl9Q z6F-4sX9+nD4z)O%)x1kIQrFbZ+w;*j4midK3h1H}DA&indFrv~bZJkj#(BrL9*vLR z4?>Y=LY|XLtl(*~DUsR)ofYa@2+?^@haBm$$ZR+DBFg4IwcF{DV-gC7<+}%^;5g8$=KiOL&*Rz=M?4(o?C$=i!OvV(xAOyU``WR;DLia!G{6?q zX|b_0>0lD7%^TkGbfSj`CGw=yies0jA9?8Hw0FbVuk-TqUI+QTZcU3`L&lIzA*E%izsZ#a-oJDDG-E zW94U`efG`j!Ve-ESFwg4Px{?_z<}+H?+R>fxY9p0HMK~~TUSfa)JxZ;1j>t7u88xD ziA9Q`-)6h#753@Z?}>iK>y{$Y+`M^nc>VLU$qR`g`%+Us_UD42rt=TBdN!0zWF$or zw|)-Ov_EtT2LBW@DmRWgAYhe#9!<{;Llw_bAL-!gw|95%LX7Z2iNrfv*mlYF>zR?3 zU5tzvFE%}DO@CEgPuYh(_1em1Ev?!cj%DK8KIe_F{frfuKc$|dzNe~cDOTCb=k+}e z9HMU|+*!#TAK)}8#l+kT+wMQ4Mjc)Eo2=c*jygfYnEJh1;g^Li_@ZCaD?bZ_1-UMT zFxA={4gB!nq~hSLqg8YLN{=3 zWyCCg()O#DjW$qu#>e@tU%$To#dg1F@ci*#yYVY&B;s{nMSL>!t6$<@Wc6goU($N4 z86xBr0aeQ;6Y59eX~2My2FwiT!BKmN9yuE~uPB5aJ{g4{y+!XneS+;wlCO^X`s*GT zQ4Zlo=N77>zZj}Y`c}rqtlB@@YJ9BWoHJbE)MmY{RD7hAj$21zbl-lYw)56e0cD+E zG^dHUgajqf9_1*RcqZ$}qIB6Ej$#q6-&Y;I>Y}XLiU_(}*bxC`W*aL{l^BZuMh>a8 zQ%;>~=-fSo8yH*@?y?6W5K^z-^mVWvGHD2>|6QsEAw8xWP}iDXYSly_@y+aF_0iR zdIj;-m!nVDTRTw=052xmnpM@+U8KVi>h5su=Xb9fB4Ta%O_8s zTv2+CQba>KowIBWobLo5IHRsGy(qk{y{PidZ)EdstePtv}a zn`?%20Y^V(%ov4CBVnRr+@q8oWk(|;nZxs?qCbqFLh=!xv~1K$;sa1jkts=Eatp~` zvfBLah0izC+_}E|x7Yc58|~Jv{hV7!^z`*Ra^&PeBl@?D&svq3`mpV@jHb2wubE5h zfGn(BQO!1%<{RWb>8V#dOMkoQQws}?GYMlXSF8`rH<}o}JSXndMzJ_k;+4SXnp#;& zz$VTY@#+;_x^$U2d-es7AY|R`K+viS-4;LR+)DSeEGN82cRB1c5EoT02|~1iBwhLcBqnT;_7C5 zbt^yhSnXgxW{k;4!Oyd-8#}}rmP^wbVH3xEyplOuRVyNsC4rG7P@@Xj9!$sWv&%bd;{S@qCnHcd%Z) zQ{xlQ#`R1ncwRJPJ2&2}zVNo`p?=1F&iG&gWINC90^t#?18|X4F>SocsOg1K1?0w0 zKMkT+JX1tCI}-xLc=B+cqiMeqKExDgI;93HI5LKe0f&q! zy_aDPows@6;Zru|=H~ZrdhMOXL5_}z3Ej1;%b96%S1mbY7IJ~~00Cq3Ap$bnbyB%B zc**{(80WWi32P@K|0pn*-SH`ut9!}jE6b0Z)DAi;3N}zc^Y};us7UeO3AwKjLa(A? z0sglS-TK5VyH@I;RMolYYNZj+d;~L-bovLTwK=ZHWp7&7R1QwswlF-IE3xgEVE0$1~!c4 z(xppZSES^MNBl_bJ(uz0RgR7_mH+s*NhuqCP^xNoNyU-^3|>)HS%ia^9{=rm%5CxJi~EG zVJh(2>fQH}00q))!rj80D+M@jc;~wcd%gsLEPUrq8DkE>lE(8*eG=~nw(Gy~=}9Q& zBJ~Gs&c%JxUKHp|SaEwvYp9NyP{|vHL@x%fU6e@}@2=)+m19tTiWfFxh81#S@YdSf zYhK+!!}_ywRMiH^ZaRrQh`1~T61E6Ma=RV*i!~F|>*k5WPYfIseQ;IDyF>B^xXoL+ z&qQTuM#ng4WF=YjY4D27SY8ge69 zRaKQ-a*bt6uE%n9b#Tj|4xiw`Zs*)88v&H9GNKNgZMW7H##GA~U zBne=pJRkb}^chx|7Kv2nU%rZ*;Iig%_D{>VUCz!nCj2{_pJT@clx=RzZ)r0^SL^oD z%l&S1)xmeRJuY3k@C7&d$!Jn%QWq4S7DgZyG8R zg2HgnV|;vXvW+w@h~M#__TsBdD@6sNB#FYp zEM>@P*2~c7x@<*|YkN^0+1FGPa;uCu1)tA)`*Y-tN`R6XRTU5p*ZY~G)0@Et`(k5b zb8?K#cjkI>-qyKXmR>=R>YLflU$zEe080( zONtw{ozQe89D zgJ5B-*Y+=%M1?>5>X~53v@{`_mr~(Sj!@vcPMFZ4?RvpbY%-a>%X3K^;{D718wm&N zP#M{pZAKta1dlo(Z%!(Dv3e+kBP6=;YJ@+eL_{X%T&MoAe{)$?O^neNuy2SI5r~J7 zhMDwho#j~sJV#7k+6L-Q`0(W9JuFaR-M7OY+Q;Wgjc&(z5cY>*a?_|%UQh-HGVdgATRsL#={bWg#;XVRNacH<5D+C~klH zzW;y$X4;zk0p2>*zfc=8r{|Dgompa9)foBL-$O%Jr7jCQ+DZtg=~F&^`0(NM!AaO5 z6kZ=nfeeu^bB*y3oCgsCG3)kNZ>>4&YH_0))?aR9Ve;BIpgkvEh;tVg&FhBcq0!ak zsyM@o+1WDUnwG&ph$Jz+$cRI8z5S3kGTIDj=lsii$unA0ZqbYqyk*N4%i+sZ>c-0E z=hGV;=1j?u#MdjK?A%;0hBzqj zW+dKt`|;fnWx?pd54Nh+A4%0s0EDc7tJ*1fpC#!SY{!8y?$P7H7Tqj)Ym|^uq%Y?dx4&LUok2!WuewU`KxFc3FSS1~Qv@r{mX}K+=rT*j*z%%K7(8#`Y>0#(- z!?;>Qb-E`_zOwSHVqSi}I4=;P6x7m|86V#d$r(xQLxJs0wI=Xbg5~1=N|h%0HLmd% zw?(?UyZG>Ylc>FM!OEQ3O`A5^J2=R!WO90kU_0}^eP^OHQ8q2b`>!B3 zLOIW5GM4|kd!(E4nvh3)aq&%}>KC6bPvlnhU?S)98;S?F+x` zTN1TGAvz|ojmE~VN#n+p?9Y#|S2u6c(&6feh%9`j=Lm4I2?;ZisK-VQYV+J=lv>I6 zFI_DS#s3Aq?@I0c&+z@?yQ)AaGNB#mrIXx)Woa(Hsc^ZEcf@>L%t*I+#Bsb{Clv;R~jsPjaX@Fz}$Mn;aAH?KGI zW#fHrgH+67z|kJQzMsJqAB5nB&n;}bSUS7gbnMAzN#_X6k_dLj+RQ>S;ncf+_0>ng zc0y{t6JZ2X)uk5&jI_*^XeLBbw?(NM-Y#R*(fM+$Yo`z{K%fV~c2X$xfdQERs^L!M zTJaxiyuRqP)|OWE?3|pQ20D8?)P*SH(r=LfXs|8ef5lC+{@}UB z6UZyKS3cURAoL@^HY1qIPNpiCJD+CuP^pzFwW|}r>YpH#k6ZG=j-z$8><(NjsuZG7 z?wqF*h4dxR>kPFqRmJZOG$z#w?7?IRr>7OaPWt$w*-#1!A-rFmMKD4g(YpT3qmxdM ziu27nDUSad!q4?NuL$C&D^)I5d1y;WrQ--^9Qol~0zSgWOvm_y-6gnk0M!BDuXyax zj1)Wjy4wP)qoOk4x`N5YoD7)*PeX)|mfKqDJGGx9QxGY08jBYsNC7G1vWIkL)j0hQs#exKgVZ=;(z3uz?a!e^GYLpA; z_U{kG-HPAn%OJ1*5a9anZSTM=4U!Q*~lT2GFKl9tkwqG>AoYLXYQ2!!-`4i3o zb7ikT04>i3U&&Sm;66*M9;bk7eegUYzgyvy72T0(Rx^P`7*CiC&4J7c{0DMn!h~7P zKXF;w_=x5mYT5p0idAu1Ku=X?wrJmsu^fOpgp=7BC=T>8RAv%XX}&cz2vicCikk0Bv(y z`H8mX*>0!|B9^fd(r$yGtU+7g_5#b;XXn1m-^w2WaL8CS{Iz0w!Wh%;i=iL2DthP#XO zVzBwi`N-utWwda@G*N7&ct5Zelb3(dr@g5ezB~Ihvyq(8DkR&p!$rkNq6r(&R8~>X zDNXOEzb35td-1#_39=0IstZ(>Dg@s4CN5vloDuFBm>Pk=E!q!P2*{gmou8LCl+MyA zd(xGh)!F`Rtao23DqnPDVx3%^KpTBA5l%)M!6u{j&*=UiRERdTaVXIAN*H(rO^iy^ zT$!oUJGC%)|2d^UM1+R^B9oY~&`Y4^&q}s*Hn-yxmZE;c=x%zNfr^hi7fLc}e&HHo7j;J05=wPc0`@&@Tfhb6d<}_CD;wI0$ z#wx-&^!+l{(hOuM^TV*y?L**^o<$gJ1sH(h@9-lF5JX+|-+lP1N>n;8y58jSO~Nja z?3H4}5HeiDgO7Uu^#Rgkh8L_^$3>|RTEQ_YRq>vG|0z$|SH{|eRiEWxPu0DszwHse zTD0ZtdjsF^nRmbb+Y96Os|X77Gr{ESvZ-#?N3PTBYW{Bi&P*Z*9f|LdhIYHEG? X`;hR%!8W@T{G<9}oL!>rw7~xaRZRwU literal 93854 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�X8_*<99jqw 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