mxflashattn 1.4.0__py3-none-any.whl

mxflashattn/reference.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import math
+
+import torch
+
+
+def attention_single(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    *,
+    softmax_scale: float | None = None,
+    causal: bool = False,
+) -> torch.Tensor:
+    """Readable PyTorch reference for [seq, heads, dim] inputs."""
+    if q.shape[0] == 0:
+        return q.clone()
+    query_len, query_heads, head_dim = q.shape
+    key_len, kv_heads, _ = k.shape
+    if key_len == 0:
+        raise ValueError("attention requires at least one key/value token")
+
+    scale = softmax_scale if softmax_scale is not None else 1.0 / math.sqrt(head_dim)
+    groups = query_heads // kv_heads
+    qf = q.float().transpose(0, 1)
+    kf = k.float().repeat_interleave(groups, dim=1).transpose(0, 1)
+    vf = v.float().repeat_interleave(groups, dim=1).transpose(0, 1)
+    scores = torch.matmul(qf, kf.transpose(-2, -1)) * scale
+
+    if causal:
+        q_positions = torch.arange(query_len, device=q.device) + (key_len - query_len)
+        k_positions = torch.arange(key_len, device=q.device)
+        blocked = k_positions.unsqueeze(0) > q_positions.unsqueeze(1)
+        scores = scores.masked_fill(blocked.unsqueeze(0), float("-inf"))
+
+    probabilities = torch.softmax(scores, dim=-1)
+    probabilities = torch.nan_to_num(probabilities, nan=0.0, posinf=0.0, neginf=0.0)
+    output = torch.matmul(probabilities, vf).transpose(0, 1)
+    return output.to(dtype=q.dtype)
+
+
+def attention_batched(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    *,
+    softmax_scale: float | None = None,
+    causal: bool = False,
+) -> torch.Tensor:
+    outputs = [
+        attention_single(q[index], k[index], v[index], softmax_scale=softmax_scale, causal=causal)
+        for index in range(q.shape[0])
+    ]
+    if not outputs:
+        return q.clone()
+    return torch.stack(outputs, dim=0)
+
+
+def attention_varlen(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    cu_seqlens_q: list[int],
+    cu_seqlens_k: list[int],
+    *,
+    softmax_scale: float | None = None,
+    causal: bool = False,
+) -> torch.Tensor:
+    outputs = []
+    for index in range(len(cu_seqlens_q) - 1):
+        q_start, q_end = cu_seqlens_q[index : index + 2]
+        k_start, k_end = cu_seqlens_k[index : index + 2]
+        outputs.append(
+            attention_single(
+                q[q_start:q_end],
+                k[k_start:k_end],
+                v[k_start:k_end],
+                softmax_scale=softmax_scale,
+                causal=causal,
+            )
+        )
+    if not outputs:
+        return q[:0].clone()
+    return torch.cat(outputs, dim=0)
+
+
+def attention_kvcache(
+    q: torch.Tensor,
+    k_cache: torch.Tensor,
+    v_cache: torch.Tensor,
+    *,
+    cache_seqlens: torch.Tensor,
+    block_table: torch.Tensor | None,
+    k: torch.Tensor | None = None,
+    v: torch.Tensor | None = None,
+    softmax_scale: float | None = None,
+    causal: bool = False,
+) -> torch.Tensor:
+    lengths = [int(length) for length in cache_seqlens.detach().cpu().tolist()]
+    batch = q.shape[0]
+    outputs = []
+
+    for batch_index in range(batch):
+        old_len = lengths[batch_index]
+        append_len = 0 if k is None else k.shape[1]
+        total_len = old_len + append_len
+        if block_table is None:
+            if append_len:
+                k_cache[batch_index, old_len:total_len] = k[batch_index]
+                v_cache[batch_index, old_len:total_len] = v[batch_index]
+            current_k = k_cache[batch_index, :total_len]
+            current_v = v_cache[batch_index, :total_len]
+        else:
+            page_size = k_cache.shape[1]
+            row = [int(block) for block in block_table[batch_index].detach().cpu().tolist()]
+            for token_index in range(append_len):
+                logical = old_len + token_index
+                page_index, page_offset = divmod(logical, page_size)
+                physical_page = row[page_index]
+                k_cache[physical_page, page_offset] = k[batch_index, token_index]
+                v_cache[physical_page, page_offset] = v[batch_index, token_index]
+            page_count = (total_len + page_size - 1) // page_size
+            pages = row[:page_count]
+            current_k = torch.cat([k_cache[page] for page in pages], dim=0)[:total_len]
+            current_v = torch.cat([v_cache[page] for page in pages], dim=0)[:total_len]
+        outputs.append(
+            attention_single(
+                q[batch_index],
+                current_k,
+                current_v,
+                softmax_scale=softmax_scale,
+                causal=causal,
+            )
+        )
+
+    if k is not None:
+        cache_seqlens.add_(k.shape[1])
+    return torch.stack(outputs, dim=0) if outputs else q.clone()

mxflashattn/validation.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import math
+from collections.abc import Sequence
+
+import torch
+
+
+SUPPORTED_HEAD_DIMS = (64, 128)
+REFERENCE_DTYPES = (torch.float16, torch.bfloat16, torch.float32)
+NATIVE_DTYPES = (torch.float16, torch.bfloat16)
+
+
+def validate_softmax_scale(softmax_scale: float | None) -> None:
+    if softmax_scale is None:
+        return
+    try:
+        scale = float(softmax_scale)
+    except (TypeError, ValueError) as error:
+        raise TypeError("softmax_scale must be a finite number or None") from error
+    if not math.isfinite(scale):
+        raise ValueError("softmax_scale must be finite")
+
+
+def validate_qkv(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> None:
+    tensors = {"q": q, "k": k, "v": v}
+    for name, tensor in tensors.items():
+        if not isinstance(tensor, torch.Tensor):
+            raise TypeError(f"{name} must be a torch.Tensor")
+        if tensor.ndim != 4:
+            raise ValueError(f"{name} must have rank 4 with layout [batch, seq, heads, dim]")
+
+    if q.device != k.device or q.device != v.device:
+        raise ValueError("q, k, and v must be on the same device")
+    if q.dtype != k.dtype or q.dtype != v.dtype:
+        raise ValueError("q, k, and v must have the same dtype")
+    if q.dtype not in REFERENCE_DTYPES:
+        raise TypeError("supported dtypes are float16, bfloat16, and float32 for reference execution")
+
+    batch, q_len, q_heads, head_dim = q.shape
+    kv_batch, kv_len, kv_heads, kv_dim = k.shape
+    if v.shape != k.shape:
+        raise ValueError("k and v must have identical shapes")
+    if batch != kv_batch:
+        raise ValueError("q, k, and v batch dimensions must match")
+    if q_heads <= 0 or kv_heads <= 0:
+        raise ValueError("q and kv head counts must be positive")
+    if q_heads % kv_heads:
+        raise ValueError("the number of q heads must be divisible by the number of kv heads")
+    if head_dim != kv_dim or head_dim not in SUPPORTED_HEAD_DIMS:
+        raise ValueError(f"head dimension must be one of {SUPPORTED_HEAD_DIMS} and match across q, k, and v")
+    if q_len < 0 or kv_len <= 0:
+        raise ValueError("q must have a non-negative sequence length and k/v must be non-empty")
+
+
+def validate_options(
+    *,
+    dropout_p: float,
+    window_size: Sequence[int],
+    softcap: float,
+    alibi_slopes: torch.Tensor | None,
+    return_attn_probs: bool,
+    deterministic: bool,
+) -> None:
+    if dropout_p != 0:
+        raise NotImplementedError("dropout is not supported in the forward-only implementation")
+    if tuple(window_size) != (-1, -1):
+        raise NotImplementedError("local window attention is not supported")
+    if softcap != 0:
+        raise NotImplementedError("soft-capping is not supported")
+    if alibi_slopes is not None:
+        raise NotImplementedError("alibi_slopes are not supported")
+    if return_attn_probs:
+        raise NotImplementedError("return_attn_probs is not supported")
+    if deterministic:
+        raise NotImplementedError("deterministic mode is not currently supported")
+
+
+def validate_cumulative_lengths(
+    cu_seqlens: torch.Tensor,
+    *,
+    total_tokens: int,
+    max_seqlen: int,
+    name: str,
+    require_non_empty: bool = False,
+) -> list[int]:
+    if not isinstance(cu_seqlens, torch.Tensor) or cu_seqlens.ndim != 1:
+        raise TypeError(f"{name} must be a one-dimensional torch.Tensor")
+    if cu_seqlens.dtype not in (torch.int32, torch.int64):
+        raise TypeError(f"{name} must use int32 or int64")
+    values = [int(value) for value in cu_seqlens.detach().cpu().tolist()]
+    if len(values) < 2 or values[0] != 0 or values[-1] != total_tokens:
+        raise ValueError(f"{name} must start at zero and cover all tokens")
+    if any(right < left for left, right in zip(values, values[1:])):
+        raise ValueError(f"{name} must be monotonically non-decreasing")
+    if require_non_empty and any(right == left for left, right in zip(values, values[1:])):
+        raise ValueError("key/value sequences must be non-empty")
+    if max_seqlen < 0 or max(values[i + 1] - values[i] for i in range(len(values) - 1)) > max_seqlen:
+        raise ValueError(f"{name} contains a sequence longer than max_seqlen")
+    return values

mxflashattn-1.4.0.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: mxflashattn
+Version: 1.4.0
+Summary: FlashAttention-compatible forward APIs and MXMACA bring-up backend
+License-Expression: Apache-2.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.4
+Requires-Dist: PyYAML<7,>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Requires-Dist: ruff<1,>=0.6; extra == "dev"
+Provides-Extra: vllm
+Requires-Dist: vllm==0.17.0; extra == "vllm"
+Provides-Extra: reports
+Requires-Dist: matplotlib<4,>=3.8; extra == "reports"
+Dynamic: license-file
+
+# MXFlashAttn
+
+> **状态（2026-10-17）：v1.4.0 C500 发布候选版本。**
+> 已完成 C500 上的算子、真实 vLLM 0.17.0 生成、dispatch、回退和近 16K 长上下文回归；
+> 生产加速范围仍限定为 M1 Split-KV Decode，不宣称 Prefill 生产加速。
+>
+> **项目边界：**这是面向 MXMACA/MetaX C500 的专项适配与 decode 优化工程，
+> 不是跨硬件 FlashAttention 替代品，也不是 MXAttention（MXFP4）复现。
+
+中文说明 · **[English](README.en.md)**
+
+MXFlashAttn 是面向 **MXMACA / MetaX C500** 的 FlashAttention 兼容前向算子与推理适配项目。
+v1.3.0 起包含**自研 device kernel**（`csrc_native/m1_kernel.cpp`，split-KV paged decode）。
+v1.4.0 在 v1.3.0 基础上完成了 C500 验证和长上下文回归。2026-10-17 的复测中，
+Qwen3-4B 在 batch=32、max_tokens=1024 的长上下文 decode 场景相对本项目 v7 路径达到约
+**3.66×** 吞吐；Qwen3-8B 在 batch=16、max_tokens=256 时约 **1.37×**。跨模型结果表明收益依赖模型、
+batch 和 KV 长度，短序列或低并发不保证加速。
+
+[![CI](https://github.com/leo1852098393-blip/MXFlashAttn/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/leo1852098393-blip/MXFlashAttn/actions/workflows/ci.yml)
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10%2B-3776AB.svg)](pyproject.toml)
+
+## 2026-10-13 C500 复测结果（申报主口径/历史对照）
+
+环境：MetaX C500 64G、MACA 3.5.3.20、驱动 3.8.30、PyTorch
+`2.8.0+metax3.5.3.9`、vLLM 0.17.0。所有 M1 结果均由 dispatch 日志确认进入
+`m1_split_decode`。
+
+| 模型与场景 | v7 | M1-UM2 | 相对 v7 |
+| --- | ---: | ---: | ---: |
+| Qwen3-4B，batch=128，256 token | 1375.59 tok/s | 4554.69 tok/s | **3.31×** |
+| Qwen3-4B，batch=32，1024 token | 359.82 tok/s | 1293.48 tok/s | **3.59×** |
+| Qwen3-8B，batch=16，256 token | 500.79 tok/s | 703.06 tok/s | **1.40×** |
+| PaddleOCR-VL，batch=16，64 token | 281.73 tok/s | 334.71 tok/s | **1.19×** |
+
+本轮最新复测为 Qwen3-4B `v7=357.76`、`M1-UM2=1309.15 tok/s`（约 **3.66×**），
+Qwen3-8B `v7=508.48`、`M1-UM2=695.45 tok/s`（约 **1.37×**）。
+这些数字只描述表中 C500 配置，不外推为所有模型或所有请求形态的固定倍率。
+另已完成 Qwen3-4B 真实 15,000 token prompt、`max_model_len=16384` 的
+vendor prefill + M1 decode 回归，生成 32 token 成功且 M1 dispatch 命中。
+流式 TTFT/P95 采集链路已验证，但 candidate 记录没有 M1 dispatch 事件，
+因此不把它写成 M1 TTFT 性能提升。
+
+2026-10-13 的复测表仍作为申报主口径和历史对照保留在
+[`docs/results/c500-2026-10-13.md`](docs/results/c500-2026-10-13.md)。
+
+2026-10-07 Gate 4 的更大场景矩阵（包括 3.67×、6.48× 等数字）保留在历史报告中，
+用于说明研发过程与形状覆盖，不与本轮复测混成同一组结果：
+[`docs/gate4/Gate4_收官报告.md`](docs/gate4/Gate4_收官报告.md)。
+
+支持形状 `{GQ in {2,4,8} x HD in {64,128}}` 的**全部6 个格子均有真实模型 E2E 证据**；
+M1 不支持的形状不得直接调用 binding。vLLM official-split 路径会把这些形状交还原始
+MetaX/vendor KV-cache 实现。2026-10-13 已用 Qwen3.5-9B（head_dim=256）验证：
+真实生成成功、M1 dispatch=0、M1-UM/M1-UM2 均为 4/4 文本匹配。
+
+新一轮原始证据和报告位于申报工作空间的本地目录 `02_evidence/c500_20261013/`；
+公开仓库内的历史 Gate 4 证据见
+[`docs/gate4/E2E_大模型与守卫验证.md`](docs/gate4/E2E_大模型与守卫验证.md)。
+
+## 快速复现（需要 C500）
+
+```bash
+export MACA_PATH=/opt/maca          # 缺这一行 triton import 会报NoneType
+bash csrc_native/build_m1.sh        # mxcc 编译 M1，产出 csrc_native/mxmmain.so
+python csrc_native/patch_plugin.py  # 把 M1 接线打进 vLLM 插件（幂等）
+python csrc_native/test_m1.py       # 稳健性矩阵：s1~s8192 / GQA 2,4,8 / bf16 / ovf
+```
+
+端到端基准（注意四个环境变量，缺任一项会静默全走 vendor 直连，三路对比退化为同一路径跑三遍）：
+
+```bash
+export MXFLASHATTN_GRAPH_OFFICIAL_SPLIT=1 MXFA_NATIVE_DECODE=1
+export VLLM_ENABLE_V1_MULTIPROCESSING=0   # EngineCore 是子进程，否则 env 热切换无效
+python csrc_native/bench_e2e.py --model /path/to/Qwen3-4B --batches 128 64 --max-tokens 256 --output artifacts/bench-q4b.json
+```
+
+**判据：先查 `dispatch.jsonl` 里 `m1_split_decode` 的事件计数，再信吞吐数字。**
+计数为 0 说明内核根本没被派发，数据无意义。
+
+## 能力矩阵
+
+| 能力 | 状态 |
+| --- | --- |
+| FP16 / BF16 forward | C500 已验证 |
+| Head dimension 64 / 128 | C500 已验证 |
+| GQA 比率 2 / 4 / 8 | C500 已验证 |
+| M1 不支持的 GQA 比率（历史验证 GQ=5/7） | 不进入 M1；由上层回退，未验证比率不作支持承诺 |
+| vLLM 中 head_dim > 128 | 不进入 M1；official split 回退原始 MetaX/vendor 路径 |
+| 直接调用 MXFlashAttn 公共 API 的 head_dim > 128 | 显式 `ValueError`，不静默计算 |
+| 自研 split-KV decode kernel（M1） | C500 已验证，vLLM 0.17.0 接线 |
+| dense / varlen / paged KV cache | API 已实现；paged KV append 已在 C500 验证 |
+| dispatch 后端 | `m1_split_decode`（M1）→ `native_decode`（v7）→ `vendor_direct` → `reference` |
+| PyTorch reference fallback | 需显式设置 `MXFLASHATTN_ALLOW_FALLBACK=1`，不会静默切换 |
+| TTFT / P95 | 流式采集链路已验证；candidate 未命中 M1，不作为 M1 性能证据 |
+| backward、FP8、多卡 | 首期不支持 |
+| SGLang | 未安装验证 |
+
+详细边界见 [`docs/support-matrix.md`](docs/support-matrix.md)。
+
+## 项目结构
+
+```text
+mxflashattn/       Python API、校验、reference 与 dispatch
+csrc/mxmac/        C++/ATen bring-up 扩展（朴素 O(n^2) 实现，正确性对照路径）
+csrc_native/       自研 M1 split-KV decode 内核 + v7 内核 + 基准/测试/构建脚本
+integrations/vllm/ vLLM 0.17.0 适配桥接、decoder adapter 与 preflight
+benchmarks/        固定配置、公平矩阵运行器和报告工具
+scripts/           C500 实例运维与 E2E 复现脚本（模型暂存、形状扫描、各模型 E2E 编排）
+docs/gate4/        Gate 4 技术报告（原始实例日志保留在本地工作空间）
+docs/results/      C500 原始结果、报告和图表
+tests/             CPU/reference 与 C500 条件测试
+```
+
+`csrc/mxmac/` 是 **PyTorch ATen bring-up / 正确性对照路径**，由 `at::matmul` + `softmax`
+组装的朴素实现，不是融合 kernel。自研 device kernel 在 `csrc_native/`。
+
+Gate 4 各档E2E 的实例侧复现脚本在 `scripts/`（对应文档各节）：
+`run_e2e_q4b.sh` / `run_e2e_q8b.sh`（GQ=4 主场景）、
+`run_e2e_gq7.sh`（GQ=7 守卫拒绝）、`run_e2e_gq8.sh`（GQ=8 PaddleOCR-VL）、
+`run_e2e_hd256.sh`（HD=256 回退验证）、`run_queue.sh`（单卡串行编排）、
+`scan_shapes.sh`（共享模型库形状扫描）和 `probe_paddle_vllm.sh`（架构探测）。
+这些公开脚本面向有 C500 的实例；模型下载与数据盘暂存脚本属于本地申报工作区，
+不随公开仓库发布。项目根目录支持通过 `MXFLASHATTN_ROOT` 覆盖，模型路径由各脚本中的
+`MODEL` 变量或命令行 `--model` 提供。
+
+## 前向算子 API
+
+公开接口：
+
+- `flash_attn_func`
+- `flash_attn_varlen_func`
+- `flash_attn_with_kvcache`
+
+```python
+import torch
+from mxflashattn import flash_attn_func, get_last_dispatch_info
+
+q = torch.randn(1, 32, 8, 64, dtype=torch.float16, device="cuda")
+k = torch.randn(1, 128, 2, 64, dtype=q.dtype, device=q.device)
+v = torch.randn_like(k)
+out = flash_attn_func(q, k, v, causal=True)
+print(get_last_dispatch_info())
+```
+
+在没有 MetaX provider 或编译扩展时，调用默认报错。只有主动设置
+`MXFLASHATTN_ALLOW_FALLBACK=1` 才启用 PyTorch reference fallback（会发`RuntimeWarning`）。
+dropout、局部窗口、AliBi、soft-capping、rotary embeddings、backward 和 softmax-LSE
+返回会明确报错，不会静默产生错误结果。
+
+## 历史基准（v0.9公平矩阵）
+
+v0.9 用固定 seed 覆盖 36 组 batch/seq/head_dim/GQA 比例/layout/dtype/causal 组合，
+在 C500 上做reference、Torch SDPA、MetaX vendor、MXFlashAttn API 四路公平对比：
+
+| 指标 | 结果 |
+| --- | --- |
+| 公平矩阵完成度 | C500 36/36 组 |
+| MXFlashAttn vs PyTorch reference | 中位延迟下降 60.52% |
+| MXFlashAttn vs MetaX vendor 直调 | 中位延迟**上升 32.74%** |
+| 最大绝对误差 | 0.00390625 |
+
+必须同时说清的口径：算子级基线是**同输入同设备的四路公平矩阵**，不是拿自写 reference
+单独对比得出的加速比；模型级 vendor 与 candidate **分栏列示**，不混入算子级 median。
+仓库早期那组 384 用例 benchmark基线是本项目 PyTorch reference，已被 v0.9 公平矩阵取代，
+仅作历史数据保留在 `docs/results/`。
+
+公开仓库提供脱敏结果摘要：[`docs/results/c500-2026-10-05.md`](docs/results/c500-2026-10-05.md)
+和 [`docs/results/c500-2026-10-13.md`](docs/results/c500-2026-10-13.md)。完整原始 JSON、
+dispatch 流和实例环境记录保留在本地申报工作空间，不随公开仓库发布。下面命令的
+`--output` 是**重新生成**时的本地输出目标。
+
+```bash
+# 评测输出默认写入被忽略的 artifacts/，只作为本地复现缓存。
+python -m benchmarks.fair_matrix --device cuda --count 36 --repeats 5 \
+  --output artifacts/fair-matrix-c500.json
+python benchmarks/fair_report.py artifacts/fair-matrix-c500.json \
+  --vendor-model artifacts/vllm-vendor-36.json \
+  --candidate-model artifacts/vllm-candidate-36.json \
+  --output artifacts/fair-matrix-c500.md
+```
+
+![C500 benchmark summary](docs/results/c500-speedup-summary.png)
+
+## vLLM 集成
+
+`integrations/vllm/vllm_plugin.py` 注册 MXFlashAttn backend。v1.3.0 起该插件在
+`MXFA_M1_DECODE=1` 时把 paged decode 派发给 M1 内核，不支持的形状自动落回 v7，
+再不支持则落回 MetaX vendor 直连。接线细节见
+[`docs/gate4/M3_VLLM_WIRING.md`](docs/gate4/M3_VLLM_WIRING.md)。
+
+```bash
+python integrations/vllm/smoke_generate.py --model /mnt/moark-models/Qwen3-0.6B \
+  --prompt-count 36 --max-tokens 16 --baseline-only \
+  --output artifacts/vllm-vendor-36.json
+```
+
+## 已知限制
+
+- **v7 路径上下文上限 4096**（>4096 启动失败）。
+- **M1 相对硬件上限仍有差距**：IR 分析显示 v7 走硬件融合`llvm.mxc.expadd.f32.i32`
+  做 softmax 重缩放，而 M1 走软件 shuffle 归约 + `exp2` 模拟。替换为硬件 intrinsic
+  是下一步方向，尚未实施。
+- **text_match 不可在连续批处理下作正确性判据**：batch 组成随调度漂移。文本一致性
+  必须在固定 batch 下单独验证（见 `csrc_native/diag_guard_text_match.py`）。
+- **dispatch 事件统计必须按 `(path, operation, fallback)` 三元组**，只按 path取 top-N
+  会在 M1 从未成功时误判为"没派发"。
+
+## 路线图
+
+后续优化与风险收敛路线见 [`docs/V1.5_OPTIMIZATION_PLAN.md`](docs/V1.5_OPTIMIZATION_PLAN.md)。
+其中包括 M1 硬件 intrinsic 评估、C500 Prefill kernel、可复现 TTFT 口径、
+自适应调度、vLLM 新版本兼容性以及 FP8/多卡/SGLang 评估；这些不属于
+v1.4.0 已完成能力。
+
+## 许可证
+
+本项目采用 [Apache License 2.0](LICENSE)。MXMACA runtime、vendor PyTorch、MetaX wheel、
+vLLM、模型权重和数据集分别遵循各自许可证。
+
+欢迎通过 [`CONTRIBUTING.md`](CONTRIBUTING.md) 提交问题和改进。

mxflashattn-1.4.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+benchmarks/__init__.py,sha256=OGcbfyPIQ9ysnubA1iPIiH5v8e-QTVG1vGYN6wLaE3U,48
+benchmarks/compare.py,sha256=5AZZRXZzBS2Wb4xL_YNsrQutkVCEczosmJuduoINgeQ,3655
+benchmarks/fair_matrix.py,sha256=8Zg_KiLTQ4Y7YCFHD-1fYUn27tj5yLofTlkqvYQ5Y6U,8342
+benchmarks/fair_report.py,sha256=8Lry2NRImH7eizEAnvO8rbv_mhcnKMNHZgYGCQv-j5A,5218
+benchmarks/model_fair_report.py,sha256=OhJZhsbF1wnLjG7SbANU0vsYGEg8Xgxldee3SN-450k,3427
+benchmarks/plot_summary.py,sha256=H76cdfWcNSR3_XqKMf5ZCwSX47WWcbAbv6Amc8deWEo,4722
+benchmarks/report.py,sha256=SLwLAxyxQD9Ku2t_uUHi9RFNFTtCOXb2lpP6V3jUMwE,6351
+benchmarks/run.py,sha256=ImTFVLYTgvAeJfShjCn3f_WaXZSb8DoqBC3rXBtFHPg,12092
+benchmarks/configs/c500.yaml,sha256=J6EvQlJ9Hu7lOmpKsxkHF2u_K4MyZIwqJg-m_EjT4yg,210
+integrations/__init__.py,sha256=3Ogvoli1FHmsLI_2vHgTmZVqgcs7zdHKy0LjG8_X4NU,44
+integrations/vllm/README.md,sha256=WUX5w8dIYcImIm6Hx3-TTHdkEzJgi2UIEXlDYzclWTg,1307
+integrations/vllm/__init__.py,sha256=VIaMdbLixoulqRTR1W_ha0K6hxXyjOk4pBrtPKL3_5M,45
+integrations/vllm/backend.py,sha256=ITIrb2lu8WQGi9XUjdpsO8RSyaEOi-6fuSxd27beq8U,6473
+integrations/vllm/compat.py,sha256=yF1FhPku64eYbVeKlBsizqTI_WlRFpD5UKGiFr-TNqI,1368
+integrations/vllm/config.py,sha256=KCeFToCCu75A8BTpdn2kqoNSu_3Va2TFZnDbg8oYGog,414
+integrations/vllm/decoder_adapter.py,sha256=uKVgwwKUrNB4bSeqNvI7JJEeakKOOykblalzPHBflS0,14836
+integrations/vllm/probe_compat.py,sha256=fGmicONVmcritXiEm-Q9W_Ik5wA_0EAYd-RaiLGZWxU,722
+integrations/vllm/probe_decoder_layout.py,sha256=D9e-OfXJObICxBJ-ON92eFBeD0eqKEJYPKu5XYeASlw,4013
+integrations/vllm/probe_registration.py,sha256=0DxyCL-GezyuIqAPNK3OCbYE73PZiYlx7ZU4CSzHJpQ,752
+integrations/vllm/probe_v017.py,sha256=U9l6ZkKorKop56a3L6BUsCdUpyJVg6mYghzCzJQjHVE,2365
+integrations/vllm/smoke_generate.py,sha256=V20kOp-FhRU-r2_6Olrlw__mQgMFXaWTBWNiW7vYOQ8,9756
+integrations/vllm/vllm_plugin.py,sha256=nG8plmhupQYDmNOS0rAO3uYvxemU8OUlK4Iyq8FbB4U,23145
+mxflashattn/__init__.py,sha256=eefPpHIpLJHuGjr0fRcx16J0_72Vl3f5lU9tVlRMWhA,947
+mxflashattn/accuracy.py,sha256=4BPB7peSM7ad-MAPw06pOURJsd2lurkEBSjXDvYXmLg,1963
+mxflashattn/api.py,sha256=0ANjh3hM8aZsMVlDBLlMOPA3wRT9YgPLousmrhmqORE,12494
+mxflashattn/dispatch.py,sha256=mBQjkBpI4QOX-dMlmatRlqSCXYCDtPC72nYtRre8XGs,6399
+mxflashattn/policy.py,sha256=X9w5C-zJ5dzJLHy9gzJldWdO3UT2fToNRppxy53yJac,3628
+mxflashattn/prefill.py,sha256=bkC7IdxGQrsmK_jsvwbwpN-WhS4lwDvPdFssLIDki2A,4031
+mxflashattn/reference.py,sha256=Nde4e_mTSbRLFJllfuXL52JS22Ie2pTQAiSla97KKB0,4866
+mxflashattn/validation.py,sha256=vE-rkeuyTI2kmKqSnrk9UOCyx8j8e7z3bUyfABf9U6E,4313
+mxflashattn-1.4.0.dist-info/licenses/LICENSE,sha256=W8keWZ0wz2Gmlbibj3pKjX8mmMSIFbBVzRAFiquPYdk,11357
+mxflashattn-1.4.0.dist-info/METADATA,sha256=6Uwd9e2JPy5ibioSW6rOg6SR3wBzn6NTk7tmUtjsgGk,12669
+mxflashattn-1.4.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+mxflashattn-1.4.0.dist-info/top_level.txt,sha256=CavV-_vqFF4S5_ZLeY0f220-9-GHqW4hDjsYQQSMCM0,36
+mxflashattn-1.4.0.dist-info/RECORD,,

mxflashattn-1.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+