liangsu9988 commited on
Commit
8a80ed7
·
verified ·
1 Parent(s): b7616fd

Promote latest kernel artifacts to main

Browse files
README.md CHANGED
@@ -1,9 +1,116 @@
1
- # flashrt/fp4-gemm
2
 
3
- This repository is a compatibility mirror for older `kernels` clients
4
- that resolve repositories through the default Hugging Face model repo API.
5
 
6
- Canonical Kernel Hub repo: https://huggingface.co/kernels/flashrt/fp4-gemm
 
 
 
7
 
8
- Do not edit this mirror by hand. It is generated from the Kernel Hub
9
- `vN` branches and contains the same `build/**` artifacts.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # fp4-gemm
2
 
3
+ FlashRT native Blackwell NVFP4 A4W4 GEMM kernels.
 
4
 
5
+ This package consumes packed FP4 E2M1 tensors plus CUTLASS Sm1xx SFA/SFB scale
6
+ buffers and produces BF16 output. It is designed to pair with
7
+ `flashrt/fp4-fused-ops` and other static low-bit transformer/diffuser runtime
8
+ paths.
9
 
10
+ ## Available Functions
11
+
12
+ - `sfa_size_bytes(rows, dim)`
13
+ - `quantize_fp4_sfa_fp16(x, packed=None, sfa=None, is_sfb=False)`
14
+ - `quantize_fp4_sfa_bf16(x, packed=None, sfa=None, is_sfb=False)`
15
+ - `dequantize_fp4_sfa_fp16(packed, sfa, out=None, is_sfb=False)`
16
+ - `nvfp4_gemm_bf16(a_packed, b_packed, sfa, sfb, alpha=1.0, out=None, variant=-1)`
17
+ - `nvfp4_gemm_bias_bf16(a_packed, b_packed, sfa, sfb, bias, out=None)`
18
+ - `nvfp4_gemm_bias_residual_bf16(a_packed, b_packed, sfa, sfb, bias, residual, out=None)`
19
+ - `nvfp4_gemm_residual_bf16(a_packed, b_packed, sfa, sfb, residual, alpha=1.0, out=None)`
20
+ - `nvfp4_gemm_bias_gelu_bf16(a_packed, b_packed, sfa, sfb, bias, alpha=1.0, out=None)`
21
+ - `nvfp4_gemm_bias_gelu_nvfp4(a_packed, b_packed, sfa, sfb, bias, alpha=1.0, out_packed=None, out_sfa=None)`
22
+ - `nvfp4_gemm_streamk_bf16(a_packed, b_packed, sfa, sfb, alpha=1.0, out=None)`
23
+ - `nvfp4_gemm_streamk_bias_bf16(a_packed, b_packed, sfa, sfb, bias, alpha=1.0, out=None)`
24
+ - `fp4_w4a16_linear_bf16(...)` is retained as a compatibility alias
25
+
26
+ ## Tensor Contract
27
+
28
+ - `a_packed`: `torch.uint8`, shape `(M, K / 2)`.
29
+ - `b_packed`: `torch.uint8`, shape `(N, K / 2)`.
30
+ - `sfa`: `torch.uint8`, CUTLASS SFA layout for `(M, K)`.
31
+ - `sfb`: `torch.uint8`, CUTLASS SFB layout for `(N, K)`.
32
+ - output: `torch.bfloat16`, shape `(M, N)`.
33
+ - `K` must be divisible by 16.
34
+ - Targets: Blackwell `sm_110a` (Jetson AGX Thor, CUDA 13+) and `sm_120a`
35
+ (RTX Blackwell, CUDA 12.8+).
36
+
37
+ `variant` selects the CUTLASS schedule:
38
+
39
+ - `-1`: architecture-aware auto-dispatch (public default).
40
+ - `0`: default `<128,128,256>` cooperative schedule.
41
+ - `1`: widen `<128,256,128>` schedule, intended for very large `N`.
42
+ - `2`: pingpong schedule for A/B testing shape-specific wins.
43
+
44
+ The canonical linear API and FP4/SFA quantize/dequantize helpers are available
45
+ on both SM110 and SM120. SM110 additionally provides the GROOT N1.7 production
46
+ epilogues `nvfp4_gemm_bias_bf16`, `nvfp4_gemm_bias_residual_bf16`, and
47
+ `nvfp4_gemm_bias_gelu_nvfp4`. The latter emits packed FP4 plus CUTLASS SFA so
48
+ the following projection can consume it without a BF16 materialization and a
49
+ standalone quantization launch. Stream-K and the older BF16 GELU epilogue keep
50
+ their existing SM120 dispatch and reject unsupported architectures explicitly.
51
+
52
+ The SM110 release gate includes the production `(M,N,K)` shapes
53
+ `(41,4608,1536)`, `(41,6144,1536)`, and `(41,1536,6144)`, plus the legacy
54
+ `M=51` compatibility row. The kernels are the native sources used by FlashRT's
55
+ GROOT N1.7 Thor NVFP4 pipeline.
56
+
57
+ ## Minimal Usage
58
+
59
+ ```python
60
+ from kernels import get_kernel
61
+ import torch
62
+
63
+ ops = get_kernel("flashrt/fp4-gemm", version=1, trust_remote_code=True)
64
+
65
+ x = torch.randn((32, 256), device="cuda", dtype=torch.float16)
66
+ w = torch.randn((512, 256), device="cuda", dtype=torch.float16)
67
+
68
+ a_packed, sfa = ops.quantize_fp4_sfa_fp16(x, is_sfb=False)
69
+ b_packed, sfb = ops.quantize_fp4_sfa_fp16(w, is_sfb=True)
70
+
71
+ y = ops.nvfp4_gemm_bf16(a_packed, b_packed, sfa, sfb, alpha=1.0)
72
+ ```
73
+
74
+ For BF16 model activations, use the direct producer so the hot path does not
75
+ materialize an intermediate FP16 tensor:
76
+
77
+ ```python
78
+ x_bf16 = torch.randn((1, 5120), device="cuda", dtype=torch.bfloat16)
79
+ a_packed, sfa = ops.quantize_fp4_sfa_bf16(x_bf16)
80
+ ```
81
+
82
+ The BF16 entry writes the same E2M1 bytes and CUTLASS SFA/SFB layout as
83
+ `quantize_fp4_sfa_fp16(x_bf16.to(torch.float16))` for finite FP16-range
84
+ inputs. It is an additive API; the existing FP16 producer remains unchanged.
85
+
86
+ The quantize/dequantize helpers are included for examples and validation. A
87
+ production runtime should keep weights prepacked and should avoid quantizing in
88
+ the hot path unless that producer kernel is part of the intended low-bit block.
89
+
90
+ Use the bias/GELU and residual variants to avoid returning to BF16
91
+ elementwise code between low-bit GEMMs. Stream-K variants are selected only
92
+ for the validated large down-projection shapes; unsupported shapes reject
93
+ rather than silently selecting a losing schedule.
94
+
95
+ ## Validation
96
+
97
+ ```bash
98
+ python fp4-gemm/tests/test_fp4_gemm.py --backend source --mode full
99
+ python fp4-gemm/tests/test_fp4_gemm.py --backend installed --mode full \
100
+ --artifact fp4-gemm/build/torch211-cxx11-cu128-x86_64-linux
101
+ python fp4-gemm/benchmarks/benchmark.py --backend installed --mode headline \
102
+ --artifact fp4-gemm/build/torch211-cxx11-cu128-x86_64-linux
103
+
104
+ # Thor model-shape gate
105
+ python fp4-gemm/tests/test_fp4_gemm.py --backend installed \
106
+ --mode thor-models \
107
+ --artifact fp4-gemm/build/torch211-cxx11-cu130-aarch64-linux
108
+ ```
109
+
110
+ The correctness reference dequantizes the same FP4/SFA and FP4/SFB inputs used
111
+ by the kernel, then computes the PyTorch GEMM reference from those dequantized
112
+ low-bit values.
113
+
114
+ The producer gate also checks the BF16 direct entry byte-for-byte against the
115
+ established FP16 compatibility chain at decode widths 5120, 6144 and 17408,
116
+ plus multi-row activation and SFB layouts.
build/torch211-cxx11-cu130-aarch64-linux/__init__.py CHANGED
@@ -19,7 +19,8 @@ def sfa_size_bytes(rows: int, dim: int) -> int:
19
  def _alloc_fp4(rows: int, dim: int, device: torch.device | str):
20
  return (
21
  torch.empty((rows, dim // 2), device=device, dtype=torch.uint8),
22
- torch.empty((sfa_size_bytes(rows, dim),), device=device, dtype=torch.uint8),
 
23
  )
24
 
25
 
@@ -36,6 +37,26 @@ def _linear_fake(
36
  return None
37
 
38
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
39
  @torch.library.register_fake(add_op_namespace_prefix("fp4_w4a4_gemv_warpsplit_bf16"))
40
  def _gemv_warpsplit_fake(a_packed, b_packed, sfa, sfb, out, alpha: float = 1.0, warps: int = 4, stages: int = 4) -> None:
41
  if a_packed.shape[0] != 1:
@@ -73,6 +94,21 @@ def _quant_fake(x: torch.Tensor, packed: torch.Tensor, sfa: torch.Tensor, is_sfb
73
  return None
74
 
75
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
76
  @torch.library.register_fake(add_op_namespace_prefix("quantize_fp4_sfa_bf16"))
77
  def _quant_bf16_fake(x: torch.Tensor, packed: torch.Tensor, sfa: torch.Tensor, is_sfb: bool = False) -> None:
78
  return None
@@ -122,6 +158,62 @@ def quantize_fp4_sfa_fp16(
122
  return packed, sfa
123
 
124
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
125
  def quantize_fp4_sfa_bf16(
126
  x: torch.Tensor,
127
  packed: torch.Tensor | None = None,
@@ -162,6 +254,100 @@ def nvfp4_gemm_bf16(
162
  return out
163
 
164
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
165
  def fp4_w4a4_gemv_warpsplit_bf16(
166
  a_packed: torch.Tensor,
167
  b_packed: torch.Tensor,
@@ -292,7 +478,7 @@ def nvfp4_gemm_bias_gelu_nvfp4(
292
  if out_packed is None:
293
  out_packed = torch.empty((m, n // 2), device=a_packed.device, dtype=torch.uint8)
294
  if out_sfa is None:
295
- out_sfa = torch.empty((sfa_size_bytes(m, n),), device=a_packed.device, dtype=torch.uint8)
296
  ops.nvfp4_gemm_bias_gelu_nvfp4(
297
  a_packed, b_packed, sfa, sfb, bias, out_packed, out_sfa, float(alpha)
298
  )
@@ -342,17 +528,24 @@ def nvfp4_gemm_streamk_bias_bf16(
342
 
343
  __all__ = [
344
  "dequantize_fp4_sfa_fp16",
 
345
  "fp4_w4a16_linear_bf16",
346
  "fp4_w4a4_gemv_warpsplit_bf16",
347
  "nvfp4_gemm_bf16",
 
 
 
 
348
  "nvfp4_gemm_bias_bf16",
349
  "nvfp4_gemm_bias_gelu_bf16",
350
  "nvfp4_gemm_bias_gelu_nvfp4",
351
  "nvfp4_gemm_bias_residual_bf16",
352
  "nvfp4_gemm_residual_bf16",
 
353
  "nvfp4_gemm_streamk_bf16",
354
  "nvfp4_gemm_streamk_bias_bf16",
355
  "quantize_fp4_sfa_fp16",
 
356
  "quantize_fp4_sfa_bf16",
357
  "sfa_size_bytes",
358
  ]
 
19
  def _alloc_fp4(rows: int, dim: int, device: torch.device | str):
20
  return (
21
  torch.empty((rows, dim // 2), device=device, dtype=torch.uint8),
22
+ # Tile-layout padding entries are not written by every quantizer.
23
+ torch.zeros((sfa_size_bytes(rows, dim),), device=device, dtype=torch.uint8),
24
  )
25
 
26
 
 
37
  return None
38
 
39
 
40
+ @torch.library.register_fake(add_op_namespace_prefix("nvfp4_gemm_fp16"))
41
+ def _linear_fp16_fake(a_packed, b_packed, sfa, sfb, out, alpha: float = 1.0, variant: int = -1) -> None:
42
+ return None
43
+
44
+
45
+ @torch.library.register_fake(add_op_namespace_prefix("nvfp4_gemm_geglu_nvfp4_fp16"))
46
+ def _geglu_fp4_fake(a, b, sfa, sfb, scratch, out_packed, out_sfa, skinny: bool = False) -> None:
47
+ return None
48
+
49
+
50
+ @torch.library.register_fake(add_op_namespace_prefix("nvfp4_gemm_bias_gelu_nvfp4_fp16"))
51
+ def _bias_gelu_fp4_fp16_fake(a, b, sfa, sfb, bias, out_packed, out_sfa) -> None:
52
+ return None
53
+
54
+
55
+ @torch.library.register_fake(add_op_namespace_prefix("nvfp4_gemm_bias_residual_fp16"))
56
+ def _bias_residual_fp16_fake(a, b, sfa, sfb, bias, residual, out) -> None:
57
+ return None
58
+
59
+
60
  @torch.library.register_fake(add_op_namespace_prefix("fp4_w4a4_gemv_warpsplit_bf16"))
61
  def _gemv_warpsplit_fake(a_packed, b_packed, sfa, sfb, out, alpha: float = 1.0, warps: int = 4, stages: int = 4) -> None:
62
  if a_packed.shape[0] != 1:
 
94
  return None
95
 
96
 
97
+ @torch.library.register_fake(add_op_namespace_prefix("quantize_e0m3_sfa_fp16"))
98
+ def _quant_e0m3_fake(x, packed, sfa, is_sfb: bool = False) -> None:
99
+ return None
100
+
101
+
102
+ @torch.library.register_fake(add_op_namespace_prefix("e0m3_weight_gemm_fp16"))
103
+ def _e0m3_gemm_fake(a, b, sfa, sfb, out, alpha: float = 1.0, a_format: int = 1) -> None:
104
+ return None
105
+
106
+
107
+ @torch.library.register_fake(add_op_namespace_prefix("nvfp4_gemm_relu2_nvfp4"))
108
+ def _relu2_gemm_fake(a, b, sfa, sfb, out_packed, out_sfa) -> None:
109
+ return None
110
+
111
+
112
  @torch.library.register_fake(add_op_namespace_prefix("quantize_fp4_sfa_bf16"))
113
  def _quant_bf16_fake(x: torch.Tensor, packed: torch.Tensor, sfa: torch.Tensor, is_sfb: bool = False) -> None:
114
  return None
 
158
  return packed, sfa
159
 
160
 
161
+ def quantize_e0m3_sfa_fp16(
162
+ x: torch.Tensor,
163
+ packed: torch.Tensor | None = None,
164
+ sfa: torch.Tensor | None = None,
165
+ is_sfb: bool = False,
166
+ ):
167
+ """Quantize FP16 to packed E0M3 with CUTLASS SFA/SFB layout."""
168
+ if packed is None or sfa is None:
169
+ packed, sfa = _alloc_fp4(x.shape[0], x.shape[1], x.device)
170
+ ops.quantize_e0m3_sfa_fp16(x, packed, sfa, bool(is_sfb))
171
+ return packed, sfa
172
+
173
+
174
+ def e0m3_weight_gemm_fp16(
175
+ a_packed: torch.Tensor,
176
+ b_packed: torch.Tensor,
177
+ sfa: torch.Tensor,
178
+ sfb: torch.Tensor,
179
+ *,
180
+ alpha: float = 1.0,
181
+ a_format: int = 1,
182
+ out: torch.Tensor | None = None,
183
+ ):
184
+ """SM110 GEMM with E0M3 weights and E2M1 or E0M3 activations."""
185
+ if out is None:
186
+ out = torch.empty(
187
+ (a_packed.shape[0], b_packed.shape[0]),
188
+ device=a_packed.device,
189
+ dtype=torch.float16,
190
+ )
191
+ ops.e0m3_weight_gemm_fp16(
192
+ a_packed, b_packed, sfa, sfb, out, float(alpha), int(a_format)
193
+ )
194
+ return out
195
+
196
+
197
+ def nvfp4_gemm_relu2_nvfp4(
198
+ a_packed: torch.Tensor,
199
+ b_packed: torch.Tensor,
200
+ sfa: torch.Tensor,
201
+ sfb: torch.Tensor,
202
+ *,
203
+ out_packed: torch.Tensor | None = None,
204
+ out_sfa: torch.Tensor | None = None,
205
+ ):
206
+ """SM110 NVFP4 GEMM with fused ReLU-squared and NVFP4 output."""
207
+ if out_packed is None or out_sfa is None:
208
+ out_packed, out_sfa = _alloc_fp4(
209
+ a_packed.shape[0], b_packed.shape[0], a_packed.device
210
+ )
211
+ ops.nvfp4_gemm_relu2_nvfp4(
212
+ a_packed, b_packed, sfa, sfb, out_packed, out_sfa
213
+ )
214
+ return out_packed, out_sfa
215
+
216
+
217
  def quantize_fp4_sfa_bf16(
218
  x: torch.Tensor,
219
  packed: torch.Tensor | None = None,
 
254
  return out
255
 
256
 
257
+ def nvfp4_gemm_fp16(
258
+ a_packed: torch.Tensor,
259
+ b_packed: torch.Tensor,
260
+ sfa: torch.Tensor,
261
+ sfb: torch.Tensor,
262
+ alpha: float = 1.0,
263
+ out: torch.Tensor | None = None,
264
+ variant: int = -1,
265
+ ) -> torch.Tensor:
266
+ """SM110 native NVFP4 GEMM with FP16 output."""
267
+ if out is None:
268
+ out = torch.empty(
269
+ (a_packed.shape[0], b_packed.shape[0]),
270
+ device=a_packed.device,
271
+ dtype=torch.float16,
272
+ )
273
+ ops.nvfp4_gemm_fp16(
274
+ a_packed, b_packed, sfa, sfb, out, float(alpha), int(variant)
275
+ )
276
+ return out
277
+
278
+
279
+ def nvfp4_gemm_geglu_nvfp4_fp16(
280
+ a_packed: torch.Tensor,
281
+ b_interleaved_packed: torch.Tensor,
282
+ sfa: torch.Tensor,
283
+ sfb: torch.Tensor,
284
+ *,
285
+ skinny: bool = False,
286
+ scratch: torch.Tensor | None = None,
287
+ out_packed: torch.Tensor | None = None,
288
+ out_sfa: torch.Tensor | None = None,
289
+ ) -> tuple[torch.Tensor, torch.Tensor]:
290
+ """GEMM with fused GeGLU and compact NVFP4 output on SM110.
291
+
292
+ ``b_interleaved_packed`` stores gate/up rows pairwise, so its first
293
+ dimension is twice the logical hidden width.
294
+ """
295
+ m, n_twice = a_packed.shape[0], b_interleaved_packed.shape[0]
296
+ hidden = n_twice // 2
297
+ if scratch is None:
298
+ scratch = torch.empty((m, hidden), device=a_packed.device, dtype=torch.uint8)
299
+ if out_packed is None:
300
+ out_packed = torch.empty((m, hidden // 2), device=a_packed.device, dtype=torch.uint8)
301
+ if out_sfa is None:
302
+ out_sfa = torch.zeros((sfa_size_bytes(m, hidden),), device=a_packed.device, dtype=torch.uint8)
303
+ ops.nvfp4_gemm_geglu_nvfp4_fp16(
304
+ a_packed, b_interleaved_packed, sfa, sfb, scratch,
305
+ out_packed, out_sfa, bool(skinny)
306
+ )
307
+ return out_packed, out_sfa
308
+
309
+
310
+ def nvfp4_gemm_bias_gelu_nvfp4_fp16(
311
+ a_packed: torch.Tensor,
312
+ b_packed: torch.Tensor,
313
+ sfa: torch.Tensor,
314
+ sfb: torch.Tensor,
315
+ bias: torch.Tensor,
316
+ *,
317
+ out_packed: torch.Tensor | None = None,
318
+ out_sfa: torch.Tensor | None = None,
319
+ ) -> tuple[torch.Tensor, torch.Tensor]:
320
+ """FP16-bias GEMM with fused GELU and NVFP4 output on SM110."""
321
+ m, n = a_packed.shape[0], b_packed.shape[0]
322
+ if out_packed is None:
323
+ out_packed = torch.empty((m, n // 2), device=a_packed.device, dtype=torch.uint8)
324
+ if out_sfa is None:
325
+ out_sfa = torch.zeros((sfa_size_bytes(m, n),), device=a_packed.device, dtype=torch.uint8)
326
+ ops.nvfp4_gemm_bias_gelu_nvfp4_fp16(
327
+ a_packed, b_packed, sfa, sfb, bias, out_packed, out_sfa
328
+ )
329
+ return out_packed, out_sfa
330
+
331
+
332
+ def nvfp4_gemm_bias_residual_fp16(
333
+ a_packed: torch.Tensor,
334
+ b_packed: torch.Tensor,
335
+ sfa: torch.Tensor,
336
+ sfb: torch.Tensor,
337
+ bias: torch.Tensor,
338
+ residual: torch.Tensor,
339
+ *,
340
+ out: torch.Tensor | None = None,
341
+ ) -> torch.Tensor:
342
+ """FP16-output GEMM with fused FP16 bias and residual on SM110."""
343
+ if out is None:
344
+ out = torch.empty_like(residual)
345
+ ops.nvfp4_gemm_bias_residual_fp16(
346
+ a_packed, b_packed, sfa, sfb, bias, residual, out
347
+ )
348
+ return out
349
+
350
+
351
  def fp4_w4a4_gemv_warpsplit_bf16(
352
  a_packed: torch.Tensor,
353
  b_packed: torch.Tensor,
 
478
  if out_packed is None:
479
  out_packed = torch.empty((m, n // 2), device=a_packed.device, dtype=torch.uint8)
480
  if out_sfa is None:
481
+ out_sfa = torch.zeros((sfa_size_bytes(m, n),), device=a_packed.device, dtype=torch.uint8)
482
  ops.nvfp4_gemm_bias_gelu_nvfp4(
483
  a_packed, b_packed, sfa, sfb, bias, out_packed, out_sfa, float(alpha)
484
  )
 
528
 
529
  __all__ = [
530
  "dequantize_fp4_sfa_fp16",
531
+ "e0m3_weight_gemm_fp16",
532
  "fp4_w4a16_linear_bf16",
533
  "fp4_w4a4_gemv_warpsplit_bf16",
534
  "nvfp4_gemm_bf16",
535
+ "nvfp4_gemm_fp16",
536
+ "nvfp4_gemm_geglu_nvfp4_fp16",
537
+ "nvfp4_gemm_bias_gelu_nvfp4_fp16",
538
+ "nvfp4_gemm_bias_residual_fp16",
539
  "nvfp4_gemm_bias_bf16",
540
  "nvfp4_gemm_bias_gelu_bf16",
541
  "nvfp4_gemm_bias_gelu_nvfp4",
542
  "nvfp4_gemm_bias_residual_bf16",
543
  "nvfp4_gemm_residual_bf16",
544
+ "nvfp4_gemm_relu2_nvfp4",
545
  "nvfp4_gemm_streamk_bf16",
546
  "nvfp4_gemm_streamk_bias_bf16",
547
  "quantize_fp4_sfa_fp16",
548
+ "quantize_e0m3_sfa_fp16",
549
  "quantize_fp4_sfa_bf16",
550
  "sfa_size_bytes",
551
  ]
build/torch211-cxx11-cu130-aarch64-linux/{_fp4_gemm_cuda_8a66d8b.abi3.so → _fp4_gemm_cuda_230e467.abi3.so} RENAMED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:35bd2043a1a1880f362954fe72a22651017d30a585d38ed5d2ffe86de286b45a
3
- size 1118808
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:f92ea3a945832ebd737cf074eac4983674fd00b160afa1481cd24148e8e32297
3
+ size 5528088
build/torch211-cxx11-cu130-aarch64-linux/_ops.py CHANGED
@@ -1,6 +1,6 @@
1
  import torch
2
- from . import _fp4_gemm_cuda_8a66d8b
3
- ops = torch.ops._fp4_gemm_cuda_8a66d8b
4
 
5
  def add_op_namespace_prefix(op_name: str):
6
- return f"_fp4_gemm_cuda_8a66d8b::{op_name}"
 
1
  import torch
2
+ from . import _fp4_gemm_cuda_230e467
3
+ ops = torch.ops._fp4_gemm_cuda_230e467
4
 
5
  def add_op_namespace_prefix(op_name: str):
6
+ return f"_fp4_gemm_cuda_230e467::{op_name}"
build/torch211-cxx11-cu130-aarch64-linux/metadata.json CHANGED
@@ -1,6 +1,6 @@
1
  {
2
  "name": "fp4-gemm",
3
- "id": "_fp4_gemm_cuda_8a66d8b",
4
  "version": 1,
5
  "license": "Apache-2.0",
6
  "python-depends": [],
@@ -13,15 +13,15 @@
13
  "digest": {
14
  "algorithm": "sha256",
15
  "files": {
16
- "__init__.py": "+Kk/VNnIWwe9nszQYvL2qtU3DpKxbqHVfklg5WtVuB4=",
17
- "_fp4_gemm_cuda_8a66d8b.abi3.so": "Nb0gQ6GhiA82KVT+cqImUQF9MKWF047V0v/obeKGtFo=",
18
- "_ops.py": "/hna1MwmSjR4pewWf12X5smsDRcaiHuoR2Gri/PrBFc=",
19
  "fp4_gemm/__init__.py": "v6p5XMfQzddhi1fLSAw4HX9CyS0rQsidvu9VsT01xi4="
20
  }
21
  },
22
  "provenance": {
23
  "kernel": {
24
- "sha": "8a66d8b",
25
  "dirty": false
26
  }
27
  }
 
1
  {
2
  "name": "fp4-gemm",
3
+ "id": "_fp4_gemm_cuda_230e467",
4
  "version": 1,
5
  "license": "Apache-2.0",
6
  "python-depends": [],
 
13
  "digest": {
14
  "algorithm": "sha256",
15
  "files": {
16
+ "__init__.py": "Qfdvg/9EedWLGh34xAalDfC0IsAHCOL44L4ShaP/w5Y=",
17
+ "_fp4_gemm_cuda_230e467.abi3.so": "+S6jqUWDLr1zfPB06sSYNnT9ALFgr6FIHNJBSOjjIpc=",
18
+ "_ops.py": "IfU2iMVrWYRnoe6q8HI3hU8TPnAlLrXDerlv117PcXI=",
19
  "fp4_gemm/__init__.py": "v6p5XMfQzddhi1fLSAw4HX9CyS0rQsidvu9VsT01xi4="
20
  }
21
  },
22
  "provenance": {
23
  "kernel": {
24
+ "sha": "230e467",
25
  "dirty": false
26
  }
27
  }
build/torch213-cxx11-cu130-aarch64-linux/{fp4_gemm_source_test.abi3.so → _fp4_gemm_cuda_230e467.abi3.so} RENAMED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:b70890b280fb1105fedaf216a5638bf1a37a866fe5f60c0b29aa547e186c8b1d
3
- size 5771504
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:54da8e4f3b0c728c6309dcb434fb608cf50085dfbf3051381ff6b1687316103c
3
+ size 5530648
build/torch213-cxx11-cu130-aarch64-linux/_ops.py CHANGED
@@ -1,6 +1,6 @@
1
  import torch
2
- from . import fp4_gemm_source_test
3
- ops = torch.ops.fp4_gemm_source_test
4
 
5
  def add_op_namespace_prefix(op_name: str):
6
- return f"fp4_gemm_source_test::{op_name}"
 
1
  import torch
2
+ from . import _fp4_gemm_cuda_230e467
3
+ ops = torch.ops._fp4_gemm_cuda_230e467
4
 
5
  def add_op_namespace_prefix(op_name: str):
6
+ return f"_fp4_gemm_cuda_230e467::{op_name}"
build/torch213-cxx11-cu130-aarch64-linux/metadata.json CHANGED
@@ -1,6 +1,6 @@
1
  {
2
  "name": "fp4-gemm",
3
- "id": "fp4_gemm_source_test",
4
  "version": 1,
5
  "license": "Apache-2.0",
6
  "python-depends": [],
@@ -14,19 +14,15 @@
14
  "algorithm": "sha256",
15
  "files": {
16
  "__init__.py": "Qfdvg/9EedWLGh34xAalDfC0IsAHCOL44L4ShaP/w5Y=",
17
- "fp4_gemm_source_test.abi3.so": "twiQsoD7EQX+2vIWpWOL8aN6hm/l9gwLKapUfhhsix0=",
18
- "_ops.py": "ZPjRxrYk7lCA0ZHoCjg8BaJyFY7a5i4NC3jIL6VMRJ4=",
19
  "fp4_gemm/__init__.py": "v6p5XMfQzddhi1fLSAw4HX9CyS0rQsidvu9VsT01xi4="
20
  }
21
  },
22
  "provenance": {
23
  "kernel": {
24
- "sha": "3a505c0",
25
  "dirty": false
26
- },
27
- "validation": {
28
- "torch": "2.13.0+cu130",
29
- "cuda": "13.0"
30
  }
31
  }
32
  }
 
1
  {
2
  "name": "fp4-gemm",
3
+ "id": "_fp4_gemm_cuda_230e467",
4
  "version": 1,
5
  "license": "Apache-2.0",
6
  "python-depends": [],
 
14
  "algorithm": "sha256",
15
  "files": {
16
  "__init__.py": "Qfdvg/9EedWLGh34xAalDfC0IsAHCOL44L4ShaP/w5Y=",
17
+ "_fp4_gemm_cuda_230e467.abi3.so": "VNqOTzsMcoxjCdy0NPtgjPUAhd+/MFE4H/axaHMWEDw=",
18
+ "_ops.py": "IfU2iMVrWYRnoe6q8HI3hU8TPnAlLrXDerlv117PcXI=",
19
  "fp4_gemm/__init__.py": "v6p5XMfQzddhi1fLSAw4HX9CyS0rQsidvu9VsT01xi4="
20
  }
21
  },
22
  "provenance": {
23
  "kernel": {
24
+ "sha": "230e467",
25
  "dirty": false
 
 
 
 
26
  }
27
  }
28
  }