From d7af878da4f902ed6b80b0bdc639d52df06a0e0f Mon Sep 17 00:00:00 2001 From: ikko-debug <862049654@qq.com> Date: Sat, 14 Mar 2026 13:29:53 +0800 Subject: [PATCH 1/3] add nf4 dequant project by ikko --- .gitignore | 5 + 03_nf4_dequant/nf4/ikko/gen_data.py | 94 + 03_nf4_dequant/nf4/ikko/main.cu | 244 ++ 03_nf4_dequant/nf4/ikko/mainla | Bin 0 -> 1039056 bytes 03_nf4_dequant/nf4/ikko/mainla.cu | 406 ++ 03_nf4_dequant/nf4/ikko/mainla.maca | 224 ++ 03_nf4_dequant/nf4/ikko/mainla.mu | 240 ++ 03_nf4_dequant/nf4/ikko/ncu_report.txt | 5051 ++++++++++++++++++++++++ 03_nf4_dequant/nf4/ikko/readme.md | 891 +++++ 03_nf4_dequant/nf4/ikko/testbit.py | 93 + 03_nf4_dequant/nf4/ikko/verify_mae.py | 85 + Makefile | 21 + 12 files changed, 7354 insertions(+) create mode 100644 .gitignore create mode 100644 03_nf4_dequant/nf4/ikko/gen_data.py create mode 100644 03_nf4_dequant/nf4/ikko/main.cu create mode 100755 03_nf4_dequant/nf4/ikko/mainla create mode 100644 03_nf4_dequant/nf4/ikko/mainla.cu create mode 100644 03_nf4_dequant/nf4/ikko/mainla.maca create mode 100644 03_nf4_dequant/nf4/ikko/mainla.mu create mode 100644 03_nf4_dequant/nf4/ikko/ncu_report.txt create mode 100644 03_nf4_dequant/nf4/ikko/readme.md create mode 100644 03_nf4_dequant/nf4/ikko/testbit.py create mode 100644 03_nf4_dequant/nf4/ikko/verify_mae.py create mode 100644 Makefile diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..185649a --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.venv/ +*.pyc +*.sqlite +*.nsys-rep +*.bin \ No newline at end of file diff --git a/03_nf4_dequant/nf4/ikko/gen_data.py b/03_nf4_dequant/nf4/ikko/gen_data.py new file mode 100644 index 0000000..d51b941 --- /dev/null +++ b/03_nf4_dequant/nf4/ikko/gen_data.py @@ -0,0 +1,94 @@ +import torch +import bitsandbytes as bnb +import struct +import os +import numpy as np + +def generate_inputs(rows=16384, cols=16384, blocksize=64, output_dir="03_nf4_dequant/nf4/ikko/data", compute_type="bf16"): + os.makedirs(output_dir, exist_ok=True) + + compute_type = compute_type.lower() + if compute_type not in {"bf16", "fp16"}: + raise ValueError("compute_type must be 'bf16' or 'fp16'") + + print(f"Generating data: {rows}x{cols}, blocksize={blocksize}, compute_type={compute_type}") + + # 1. 准备原始权重 (使用 GPU 和 BF16) + device = torch.device("cuda") + # 模拟真实权重分布 (Normal Float 4 针对正态分布优化) + orig_weight = torch.randn(rows, cols, dtype=torch.bfloat16, device=device) + + # 2. 使用 bitsandbytes 进行 NF4 + Double Quantization + # quant_type='nf4', compress_statistics=True 开启双重量化 + packed_weight, quant_state = bnb.functional.quantize_4bit( + orig_weight, + blocksize=blocksize, + quant_type='nf4', + compress_statistics=True + ) + + # 3. 生成官方参考结果 (Ground Truth) + # CUDA Kernel 输出必须逼近这个结果 + ref_output = bnb.functional.dequantize_4bit( + packed_weight, + quant_state, + quant_type='nf4', + blocksize=blocksize + ) + + # 4. 提取双重量化参数 (为了写入 input bin 文件) + # bitsandbytes 的 QuantState 结构解析: + # - absmax: 一级量化因子 (已被二级量化，uint8) + # - nested quant state: 兼容 nested_quant_state / state2 + absmax_q = quant_state.absmax.to(torch.uint8) # uint8 + nested_state = getattr(quant_state, "nested_quant_state", None) + if nested_state is None: + nested_state = getattr(quant_state, "state2", None) + if nested_state is None: + raise RuntimeError( + "Double-quantization state not found. " + "Please ensure bitsandbytes supports compress_statistics=True " + "and provides nested quantization fields." + ) + absmax2 = nested_state.absmax # float32 (需转 float16) + code2 = nested_state.code # float32 (需转 float16) + offset = getattr(quant_state, "offset", 0.0) + if isinstance(offset, torch.Tensor): + offset = float(offset.item()) + + # 5. 写入题目要求的二进制输入文件 (weight.bin) + input_path = os.path.join(output_dir, "weight_data.bin") + with open(input_path, "wb") as f: + # [Header] + f.write(struct.pack("qqi", rows, cols, blocksize)) + + # [Data] + # packed_weights (uint8) + f.write(packed_weight.cpu().numpy().tobytes()) + # absmax_q (uint8) + f.write(absmax_q.cpu().numpy().tobytes()) + # absmax2 (float16) + f.write(absmax2.to(torch.float16).cpu().numpy().tobytes()) + # code2 (float16) + f.write(code2.to(torch.float16).cpu().numpy().tobytes()) + # offset (float32) + f.write(struct.pack("f", float(offset))) + + print(f"-> Input file saved to: {input_path}") + + # 6. 保存 Ground Truth 用于后续验证 (truth.bin) + truth_path = os.path.join(output_dir, "ground_truth.bin") + with open(truth_path, "wb") as f: + # 保存为纯二进制流 (row-major, bf16/fp16) + if compute_type == "bf16": + ref_out = ref_output.to(torch.bfloat16) + ref_bytes = ref_out.view(torch.int16).cpu().numpy().tobytes() + else: + ref_out = ref_output.to(torch.float16) + ref_bytes = ref_out.cpu().numpy().tobytes() + f.write(ref_bytes) + + print(f"-> Ground truth saved to: {truth_path}") + +if __name__ == "__main__": + generate_inputs(compute_type="bf16") \ No newline at end of file diff --git a/03_nf4_dequant/nf4/ikko/main.cu b/03_nf4_dequant/nf4/ikko/main.cu new file mode 100644 index 0000000..fd42929 --- /dev/null +++ b/03_nf4_dequant/nf4/ikko/main.cu @@ -0,0 +1,244 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +struct Header { + int64_t num_rows; + int64_t num_cols; + int32_t blocksize; +}; +__constant__ float NF4_LUT[16] = { + -1.0f, // 0b0000 + -0.6961928009986877f, // 0b0001 + -0.5250730514526367f, // 0b0010 + -0.39491748809814453f, // 0b0011 + -0.28444138169288635f, // 0b0100 + -0.18477343022823334f, // 0b0101 + -0.09105003625154495f, // 0b0110 + 0.0f, // 0b0111 + 0.07958029955625534f, // 0b1000 + 0.16093020141124725f, // 0b1001 + 0.24611230194568634f, // 0b1010 + 0.33791524171829224f, // 0b1011 + 0.44070982933044434f, // 0b1100 + 0.5626170039176941f, // 0b1101 + 0.7229568362236023f, // 0b1110 + 1.0f // 0b1111 +}; +void checkCuda(cudaError_t result, const char *func, const char *file, int line) { + if (result != cudaSuccess) { + std::cerr << "CUDA error at " << file << ":" << line << " code=" << result << " \"" << func << "\" \n"; + std::cerr << "Error string: " << cudaGetErrorString(result) << std::endl; + exit(99); + } +} +#define CHECK_CUDA(val) checkCuda((val), #val, __FILE__, __LINE__) + +__global__ void nf4_decode_kernel_native( + const uint8_t* __restrict__ packed_weights, + const uint8_t* __restrict__ absmax_q, + const half* __restrict__ absmax2, + const half* __restrict__ code2, + const float offset, // 通常为 0 + __nv_bfloat16* __restrict__ output, + int64_t num_elements, + int blocksize +) { + // 1. 全局一维线程索引 + // 每个线程负责 1 个字节（即 2 个 4-bit 权重） + int64_t tid = blockIdx.x * blockDim.x + threadIdx.x; + int64_t total_bytes = num_elements / 2; + + // 边界检查：多余的线程直接退出 + if (tid >= total_bytes) return; + + // 2. 读取这 1 个字节，并解包成两个 4-bit 索引 + uint8_t packed = packed_weights[tid]; + uint8_t idx1 = packed & 0x0F; + uint8_t idx2 = (packed >> 4) & 0x0F; + + // 3. 计算当前字节属于哪一个量化 Block 和 Group + // 每一个 Block 包含 blocksize 个权重，即 blocksize / 2 个字节 + int bytes_per_block = blocksize / 2; + int block_id = tid / bytes_per_block; // 当前 byte 属于第几个 64-weight block + int group_id = block_id / 256; // bitsandbytes 默认每组 256 个 block，256 个 block 共享一个 absmax2 + + // 4. 从全局内存 (Global Memory) 读取双重量化参数 + float a2 = __half2float(absmax2[group_id]); // 读取二级缩放 + uint8_t qa = absmax_q[block_id]; // 读取一级缩放索引 + float c2 = __half2float(code2[qa]); // 查码表解码一级缩放 + float real_absmax = c2 * a2; // 计算最终缩放因子 + + // 5. 结合 NF4 查表，计算真实的浮点权重 + float w1_fp32 = NF4_LUT[idx1] * real_absmax + offset; + float w2_fp32 = NF4_LUT[idx2] * real_absmax + offset; + + // 6. 最朴素的分别写回 + output[tid * 2] = __float2bfloat16(w1_fp32); + output[tid * 2 + 1] = __float2bfloat16(w2_fp32); +} + +__global__ void nf4_decode_kernel( + const uint8_t* __restrict__ packed_weights, + const uint8_t* __restrict__ absmax_q, + const half* __restrict__ absmax2, + const half* __restrict__ code2, + const float offset, // 通常为 0 + __nv_bfloat16* __restrict__ output, + int64_t num_elements, + int blocksize +) { + +} + + + +int main(int argc, char** argv) { +// 1.输入解析，读取二进制文件 + std::string input_file = "test_data/weight_data.bin"; + std::string output_file = "test_data/output.bin"; + std::ifstream infile(input_file, std::ios::binary); + if (!infile) { + std::cerr << "Error: Cannot open input file." << std::endl; + return 1; + } + +// 1. 读取 Header + int64_t num_rows, num_cols; + int32_t blocksize; + infile.read(reinterpret_cast(&num_rows), sizeof(int64_t)); + infile.read(reinterpret_cast(&num_cols), sizeof(int64_t)); + infile.read(reinterpret_cast(&blocksize), sizeof(int32_t)); +// 2.内存规划 + Header header{num_rows, num_cols, blocksize}; + int64_t num_elements = num_rows * num_cols; + int64_t num_blocks = (num_elements + blocksize - 1) / blocksize; + int64_t num_groups = (num_blocks + 255) / 256; // 每个 block 256 个线程 + +// 3.数据加载，分配显存 + size_t size_packed = num_elements >>1; //需要 num_elements / 2 个字节，一个 byte 存 2 个权重 + size_t size_absmax_q = num_blocks * sizeof(uint8_t); + size_t size_absmax2 = num_groups * sizeof(half); // float16 + size_t size_code2 = 256 * sizeof(half); // float16 + float offset; // float32 + + std::vector h_packed(size_packed); + std::vector h_absmax_q(num_blocks); + std::vector h_absmax2(num_groups); + std::vector h_code2(256); + + infile.read(reinterpret_cast(h_packed.data()), size_packed); + infile.read(reinterpret_cast(h_absmax_q.data()), size_absmax_q); + infile.read(reinterpret_cast(h_absmax2.data()), size_absmax2); + infile.read(reinterpret_cast(h_code2.data()), size_code2); + infile.read(reinterpret_cast(&offset), sizeof(float)); + + infile.close(); + // 分配 device 内存 + uint8_t* d_packed = nullptr; + uint8_t* d_absmax_q = nullptr; + half* d_absmax2 = nullptr; + half* d_code2 = nullptr; + __nv_bfloat16 *d_output; + + CHECK_CUDA(cudaMalloc(&d_packed, size_packed)); + CHECK_CUDA(cudaMalloc(&d_absmax_q, size_absmax_q)); + CHECK_CUDA(cudaMalloc(&d_absmax2, size_absmax2)); + CHECK_CUDA(cudaMalloc(&d_code2, size_code2)); + CHECK_CUDA(cudaMalloc(&d_output, num_elements * sizeof(__nv_bfloat16))); + CHECK_CUDA(cudaMemcpy(d_packed, h_packed.data(), size_packed, cudaMemcpyHostToDevice)); + CHECK_CUDA(cudaMemcpy(d_absmax_q, h_absmax_q.data(), size_absmax_q, cudaMemcpyHostToDevice)); + CHECK_CUDA(cudaMemcpy(d_absmax2, h_absmax2.data(), size_absmax2, cudaMemcpyHostToDevice)); + CHECK_CUDA(cudaMemcpy(d_code2, h_code2.data(), size_code2, cudaMemcpyHostToDevice)); + + + +// 4. 启动 CUDA Kernel + dim3 blockDim(256); + dim3 blockDim(256); + int64_t total_bytes = (num_elements + 1) / 2; + int64_t total_words = (total_bytes + 15) / 16; + int sm_count = 0; + CHECK_CUDA(cudaDeviceGetAttribute(&sm_count, cudaDevAttrMultiProcessorCount, 0)); + int max_active_blocks = 0; + CHECK_CUDA(cudaOccupancyMaxActiveBlocksPerMultiprocessor( + &max_active_blocks, + nf4_decode_kernel, + blockDim.x, + 0)); + int grid_x = sm_count * max_active_blocks; + int64_t max_grid = (total_words + blockDim.x - 1) / blockDim.x; + if (grid_x > max_grid) { + grid_x = static_cast(max_grid); + } + if (grid_x < 1) { + grid_x = 1; + } + dim3 gridDim(grid_x); + std::cout << "SM count: " << sm_count + << ", max active blocks/SM: " << max_active_blocks + << ", grid_x: " << grid_x << std::endl; + int group_size = static_cast((num_blocks + num_groups - 1) / num_groups); + // kernel 函数需要完成 NF4 解码的核心计算逻辑 + // 计时事件 + cudaEvent_t start, stop; + CHECK_CUDA(cudaEventCreate(&start)); + CHECK_CUDA(cudaEventCreate(&stop)); + + // Warmup + nf4_decode_kernel<<>>( + d_packed, d_absmax_q, d_absmax2, d_code2, offset, d_output, num_elements, blocksize + ); + CHECK_CUDA(cudaDeviceSynchronize()); + + const int iters = 100; + CHECK_CUDA(cudaEventRecord(start)); + for (int i = 0; i < iters; ++i) { + nf4_decode_kernel<<>>( + d_packed, d_absmax_q, d_absmax2, d_code2, offset, d_output, num_elements, blocksize + ); + } + CHECK_CUDA(cudaEventRecord(stop)); +// 5.记录性能，写入数据 + CHECK_CUDA(cudaGetLastError()); + CHECK_CUDA(cudaEventSynchronize(stop)); + + float milliseconds = 0; + CHECK_CUDA(cudaEventElapsedTime(&milliseconds, start, stop)); + milliseconds /= iters; + +// 6. D2H 拷贝结果 + std::vector<__nv_bfloat16> h_output(num_elements); + CHECK_CUDA(cudaMemcpy(h_output.data(), d_output, num_elements * sizeof(__nv_bfloat16), cudaMemcpyDeviceToHost)); + +// 7. 计算并打印性能 + double total_bytes = static_cast(size_packed + size_absmax_q + size_absmax2 + size_code2) + + static_cast(num_elements * 2); + double bandwidth = total_bytes / (milliseconds / 1000.0) / 1e9; + std::cout << "Kernel Time: " << milliseconds << " ms" << std::endl; + std::cout << "Effective Bandwidth (approx): " << bandwidth << " GB/s" << std::endl; + +// 8. 写入输出文件 + std::ofstream outfile(output_file, std::ios::binary); + outfile.write(reinterpret_cast(h_output.data()), num_elements * sizeof(__nv_bfloat16)); + outfile.close(); + std::cout << "Output written to " << output_file << std::endl; + + // 清理 + cudaFree(d_packed); + cudaFree(d_absmax_q); + cudaFree(d_absmax2); + cudaFree(d_code2); + cudaFree(d_output); + cudaEventDestroy(start); + cudaEventDestroy(stop); + + return 0; +} \ No newline at end of file diff --git a/03_nf4_dequant/nf4/ikko/mainla b/03_nf4_dequant/nf4/ikko/mainla new file mode 100755 index 0000000000000000000000000000000000000000..ad85050411723f5c98bb2f7bc92c620f8a358f54 GIT binary patch literal 1039056 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 z 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

>C!1tPmdbSIz!N#`XX;;r`J&woPZzgQ_p- z!TBJM@?bMHy{L(rnK~1xiKakP7ml{`#EDl>a~Ata?0Hh_$n3{F=vQAeM>Wq-^DVB{ z@Sw#c)%;gds5ojK5054L<^1_%#2sOC0m@YBJV_~A;U=?@L& z!EE3l4`Tw?Z7cpWHP`4)qJcS8n^F@EwI%FZcuRQ7#1S=Tu%E;&rq0SFJ!oHFGg>vL zQ}Z=0>+m4UXhu;J)>a=qsHmH2j&zb^x)2&H2?b_ew}Zxdu)qq@Swq!qr{+Ft!kK16 zvaJO@xC=PQ4={m`^58vcuBIkhd$%5+$<#!#EwR+RQ8SUJO#D1Gr?Q_!jd{Z%3mVLW zl=_;Us>v87{d|f206b`B#&+-w&VyCk?4V4YW~xb2^8z&RV9ygewgu4Wc#4zbtq`4U z;#7{?acuWc6ZSV_8w3sJK`wBR{{g8UnD?uiQgbCW(Nt5XIWlzvWT zKZydPS$jG?`0#UEzIm1>6lLo}ab4*?I>n{#0-HQ}`Sni@{aIG>v5xW7rRHGAz& z(AW?9^tD2CHcvGJsFD2*&V@NfQ*#Tbq1otkLJXGg

A{%#nzfu_@rl%YjC}_@81fID*Au7-GwW+6sb)`x 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℘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%0AIN_-)n7XJ{>h<85N@@K_| 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.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 XZ#(ycr^x@|Z)ufXcV#3n+U))hGyPYy literal 0 HcmV?d00001 diff --git a/03_nf4_dequant/nf4/ikko/mainla.cu b/03_nf4_dequant/nf4/ikko/mainla.cu new file mode 100644 index 0000000..1008a4f --- /dev/null +++ b/03_nf4_dequant/nf4/ikko/mainla.cu @@ -0,0 +1,406 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +// struct Header { +// int64_t num_rows; +// int64_t num_cols; +// int32_t blocksize; +// }; +__constant__ float NF4_LUT[16] = { + -1.0f, // 0b0000 + -0.6961928009986877f, // 0b0001 + -0.5250730514526367f, // 0b0010 + -0.39491748809814453f, // 0b0011 + -0.28444138169288635f, // 0b0100 + -0.18477343022823334f, // 0b0101 + -0.09105003625154495f, // 0b0110 + 0.0f, // 0b0111 + 0.07958029955625534f, // 0b1000 + 0.16093020141124725f, // 0b1001 + 0.24611230194568634f, // 0b1010 + 0.33791524171829224f, // 0b1011 + 0.44070982933044434f, // 0b1100 + 0.5626170039176941f, // 0b1101 + 0.7229568362236023f, // 0b1110 + 1.0f // 0b1111 +}; +void checkCuda(cudaError_t result, const char *func, const char *file, int line) { + if (result != cudaSuccess) { + std::cerr << "CUDA error at " << file << ":" << line << " code=" << result << " \"" << func << "\" \n"; + std::cerr << "Error string: " << cudaGetErrorString(result) << std::endl; + exit(99); + } +} +#define CHECK_CUDA(val) checkCuda((val), #val, __FILE__, __LINE__) + +template +__device__ __forceinline__ T float_to_out(float v); + +template <> +__device__ __forceinline__ __nv_bfloat16 float_to_out<__nv_bfloat16>(float v) { + return __float2bfloat16(v); +} + +template <> +__device__ __forceinline__ half float_to_out(float v) { + return __float2half(v); +} + +template +__device__ __forceinline__ uint32_t pack_pair_to_u32(float v1, float v2); + +template <> +__device__ __forceinline__ uint32_t pack_pair_to_u32<__nv_bfloat16>(float v1, float v2) { + __nv_bfloat162 packed = __floats2bfloat162_rn(v1, v2); + return *reinterpret_cast(&packed); +} + +template <> +__device__ __forceinline__ uint32_t pack_pair_to_u32(float v1, float v2) { + half2 packed = __floats2half2_rn(v1, v2); + return *reinterpret_cast(&packed); +} + +// __global__ void nf4_decode_kernel_native( +// const uint8_t* __restrict__ packed_weights, +// const uint8_t* __restrict__ absmax_q, +// const half* __restrict__ absmax2, +// const half* __restrict__ code2, +// const float offset, // 通常为 0 +// __nv_bfloat16* __restrict__ output, +// int64_t num_elements, +// int blocksize, +// int group_size +// ) { +// // 1. 全局一维线程索引 +// // 每个线程负责 1 个字节（即 2 个 4-bit 权重） +// int64_t tid = blockIdx.x * blockDim.x + threadIdx.x; +// int64_t total_bytes = (num_elements + 1) / 2; +// int64_t stride = static_cast(gridDim.x) * blockDim.x; + +// for (int64_t byte_idx = tid; byte_idx < total_bytes; byte_idx += stride) { +// // 2. 读取这 1 个字节，并解包成两个 4-bit 索引 +// uint8_t packed = packed_weights[byte_idx]; +// uint8_t idx1 = (packed >> 4) & 0x0F; // 高 4 位对应 output[byte_idx * 2] +// uint8_t idx2 = packed & 0x0F; // 低 4 位对应 output[byte_idx * 2 + 1] + +// // 3. 计算当前字节属于哪一个量化 Block 和 Group +// // 每一个 Block 包含 blocksize 个权重，即 blocksize / 2 个字节 +// int bytes_per_block = blocksize / 2; +// int block_id = static_cast(byte_idx / bytes_per_block); +// int group_id = block_id / group_size; + +// // 4. 暴力从全局内存 (Global Memory) 读取双重量化参数 +// float a2 = __half2float(absmax2[group_id]); +// uint8_t qa = absmax_q[block_id]; +// float c2 = __half2float(code2[qa]); +// float real_absmax = c2 * a2 + offset; + +// // 5. 结合 NF4 查表，计算真实的浮点权重 +// float w1_fp32 = NF4_LUT[idx1] * real_absmax; +// float w2_fp32 = NF4_LUT[idx2] * real_absmax; + +// // 6. 分别写回 +// int64_t out_idx = byte_idx * 2; +// if (out_idx < num_elements) { +// output[out_idx] = __float2bfloat16(w1_fp32); +// } +// if (out_idx + 1 < num_elements) { +// output[out_idx + 1] = __float2bfloat16(w2_fp32); +// } +// } +// } + +template +__global__ void nf4_decode_kernel( + const uint8_t* __restrict__ packed_weights, + const uint8_t* __restrict__ absmax_q, + const half* __restrict__ absmax2, + const half* __restrict__ code2, + const float offset, + OutT* __restrict__ output, + int64_t num_elements, + int blocksize, + int group_size +) { + int64_t tid = blockIdx.x * blockDim.x + threadIdx.x; + int64_t stride = gridDim.x * blockDim.x; + int64_t total_bytes = (num_elements + 1) / 2; + int64_t full_pair_bytes = num_elements / 2; + unsigned warp_mask = 0xffffffffu; + int lane = threadIdx.x & 31; + + __shared__ float s_LUT[16]; + if (threadIdx.x < 16) { + s_LUT[threadIdx.x] = NF4_LUT[threadIdx.x]; + } + __syncthreads(); + uint32_t* out_u32 = reinterpret_cast(output); + + for (int64_t byte_idx = tid; byte_idx < full_pair_bytes; byte_idx += stride) { + uint8_t packed = packed_weights[byte_idx]; + int block_id = static_cast(byte_idx / (blocksize / 2)); + int group_id = block_id / group_size; + float real_absmax = 0.0f; + if (lane == 0) { + uint8_t qa = absmax_q[block_id]; + real_absmax = (__half2float(absmax2[group_id]) * __half2float(code2[qa])) + offset; + } + real_absmax = __shfl_sync(warp_mask, real_absmax, 0); + float v1 = s_LUT[packed >> 4] * real_absmax; + float v2 = s_LUT[packed & 0x0F] * real_absmax; + out_u32[byte_idx] = pack_pair_to_u32(v1, v2); + } + + if ((num_elements & 1) != 0) { + int64_t tail_byte = total_bytes - 1; + if (tid == 0) { + uint8_t packed = packed_weights[tail_byte]; + int block_id = static_cast(tail_byte / (blocksize / 2)); + int group_id = block_id / group_size; + float real_absmax = (__half2float(absmax2[group_id]) * __half2float(code2[absmax_q[block_id]])) + offset; + output[num_elements - 1] = float_to_out(s_LUT[packed >> 4] * real_absmax); + } + } +} + +int main(int argc, char** argv) { +// 1.输入解析，读取二进制文件 + std::string input_file = "03_nf4_dequant/nf4/ikko/data/weight_data.bin"; + std::string output_file = "03_nf4_dequant/nf4/ikko/data/output.bin"; + enum class OutputType { BF16, FP16 }; + OutputType output_type = OutputType::BF16; + if (argc >= 2) { + if (std::strcmp(argv[1], "bf16") == 0) { + output_type = OutputType::BF16; + output_file = "03_nf4_dequant/nf4/ikko/data/output_bf16.bin"; + } else if (std::strcmp(argv[1], "fp16") == 0) { + output_type = OutputType::FP16; + output_file = "03_nf4_dequant/nf4/ikko/data/output_fp16.bin"; + } else { + std::cerr << "Usage: " << argv[0] << " [bf16|fp16] [output_file]" << std::endl; + return 1; + } + } + if (argc >= 3) { + output_file = argv[2]; + } + std::ifstream infile(input_file, std::ios::binary); + if (!infile) { + char cwd[4096]; + if (getcwd(cwd, sizeof(cwd)) != nullptr) { + std::cerr << "CWD: " << cwd << std::endl; + } + std::cerr << "Error: Cannot open input file: " << input_file << std::endl; + std::string fallback_file = "03_nf4_dequant/nf4/ikko/data/weight_data.bin"; + infile.open(fallback_file, std::ios::binary); + if (!infile) { + std::cerr << "Error: Cannot open fallback input file: " << fallback_file << std::endl; + return 1; + } + input_file = fallback_file; + } + +// 1. 读取 Header + int64_t num_rows, num_cols; + int32_t blocksize; + infile.read(reinterpret_cast(&num_rows), sizeof(int64_t)); + infile.read(reinterpret_cast(&num_cols), sizeof(int64_t)); + infile.read(reinterpret_cast(&blocksize), sizeof(int32_t)); + std::streampos data_start = infile.tellg(); + infile.seekg(0, std::ios::end); + int64_t file_size = static_cast(infile.tellg()); + infile.seekg(data_start, std::ios::beg); +// 2.内存规划 + // Header header{num_rows, num_cols, blocksize}; + int64_t num_elements = num_rows * num_cols; + int64_t num_blocks = (num_elements + blocksize - 1) / blocksize; + int64_t num_groups = 0; + +// 3.数据加载，分配显存 + size_t size_packed = num_elements >> 1; // 需要 num_elements / 2 个字节，一个 byte 存 2 个权重 + size_t size_packed_padded = (size_packed + 15) & ~static_cast(15); + size_t size_absmax_q = num_blocks * sizeof(uint8_t); + size_t size_absmax2 = 0; // float16 + size_t size_code2 = 256 * sizeof(half); // float16 + float offset; // float32 + + std::vector h_packed(size_packed_padded, 0); + std::vector h_absmax_q(num_blocks); + // 推断 num_groups（兼容不同 bitsandbytes 版本的分组大小） + int64_t header_size = static_cast(sizeof(int64_t) * 2 + sizeof(int32_t)); + int64_t remaining = file_size - header_size - + static_cast(size_packed + size_absmax_q + size_code2 + sizeof(float)); + if (remaining > 0 && (remaining % sizeof(half) == 0)) { + num_groups = remaining / static_cast(sizeof(half)); + size_absmax2 = static_cast(num_groups) * sizeof(half); + } else { + num_groups = (num_blocks + 255) / 256; + size_absmax2 = static_cast(num_groups) * sizeof(half); + } + + std::vector h_absmax2(num_groups); + std::vector h_code2(256); + + infile.read(reinterpret_cast(h_packed.data()), size_packed); + infile.read(reinterpret_cast(h_absmax_q.data()), size_absmax_q); + infile.read(reinterpret_cast(h_absmax2.data()), size_absmax2); + infile.read(reinterpret_cast(h_code2.data()), size_code2); + infile.read(reinterpret_cast(&offset), sizeof(float)); + + infile.close(); + // 分配 device 内存 + uint8_t* d_packed = nullptr; + uint8_t* d_absmax_q = nullptr; + half* d_absmax2 = nullptr; + half* d_code2 = nullptr; + __nv_bfloat16 *d_output_bf16 = nullptr; + half *d_output_fp16 = nullptr; + + CHECK_CUDA(cudaMalloc(&d_packed, size_packed_padded)); + CHECK_CUDA(cudaMalloc(&d_absmax_q, size_absmax_q)); + CHECK_CUDA(cudaMalloc(&d_absmax2, size_absmax2)); + CHECK_CUDA(cudaMalloc(&d_code2, size_code2)); + if (output_type == OutputType::BF16) { + CHECK_CUDA(cudaMalloc(&d_output_bf16, num_elements * sizeof(__nv_bfloat16))); + } else { + CHECK_CUDA(cudaMalloc(&d_output_fp16, num_elements * sizeof(half))); + } + CHECK_CUDA(cudaMemcpy(d_packed, h_packed.data(), size_packed_padded, cudaMemcpyHostToDevice)); + CHECK_CUDA(cudaMemcpy(d_absmax_q, h_absmax_q.data(), size_absmax_q, cudaMemcpyHostToDevice)); + CHECK_CUDA(cudaMemcpy(d_absmax2, h_absmax2.data(), size_absmax2, cudaMemcpyHostToDevice)); + CHECK_CUDA(cudaMemcpy(d_code2, h_code2.data(), size_code2, cudaMemcpyHostToDevice)); + + + +// 4. 启动 CUDA Kernel + dim3 blockDim(256); + int64_t total_bytes = (num_elements + 1) / 2; + int sm_count = 0; + CHECK_CUDA(cudaDeviceGetAttribute(&sm_count, cudaDevAttrMultiProcessorCount, 0)); + int max_active_blocks = 0; + if (output_type == OutputType::BF16) { + CHECK_CUDA(cudaOccupancyMaxActiveBlocksPerMultiprocessor( + &max_active_blocks, + nf4_decode_kernel<__nv_bfloat16>, + blockDim.x, + 0)); + } else { + CHECK_CUDA(cudaOccupancyMaxActiveBlocksPerMultiprocessor( + &max_active_blocks, + nf4_decode_kernel, + blockDim.x, + 0)); + } + int grid_x = sm_count * max_active_blocks; + int64_t max_grid = (total_bytes + blockDim.x - 1) / blockDim.x; + if (grid_x > max_grid) { + grid_x = static_cast(max_grid); + } + if (grid_x < 1) { + grid_x = 1; + } + dim3 gridDim(grid_x); + std::cout << "SM count: " << sm_count + << ", max active blocks/SM: " << max_active_blocks + << ", grid_x: " << grid_x << std::endl; + int group_size = static_cast((num_blocks + num_groups - 1) / num_groups); + // kernel 函数需要完成 NF4 解码的核心计算逻辑 + // 计时事件 + cudaEvent_t start, stop; + CHECK_CUDA(cudaEventCreate(&start)); + CHECK_CUDA(cudaEventCreate(&stop)); + + // Warmup + if (output_type == OutputType::BF16) { + nf4_decode_kernel<__nv_bfloat16><<>>( + d_packed, d_absmax_q, d_absmax2, d_code2, offset, d_output_bf16, num_elements, blocksize, group_size + ); + } else { + nf4_decode_kernel<<>>( + d_packed, d_absmax_q, d_absmax2, d_code2, offset, d_output_fp16, num_elements, blocksize, group_size + ); + } + CHECK_CUDA(cudaDeviceSynchronize()); + + const int iters = 100; + CHECK_CUDA(cudaEventRecord(start)); + for (int i = 0; i < iters; ++i) { + if (output_type == OutputType::BF16) { + nf4_decode_kernel<__nv_bfloat16><<>>( + d_packed, d_absmax_q, d_absmax2, d_code2, offset, d_output_bf16, num_elements, blocksize, group_size + ); + } else { + nf4_decode_kernel<<>>( + d_packed, d_absmax_q, d_absmax2, d_code2, offset, d_output_fp16, num_elements, blocksize, group_size + ); + } + } + CHECK_CUDA(cudaEventRecord(stop)); +// 5.记录性能，写入数据 + CHECK_CUDA(cudaGetLastError()); + CHECK_CUDA(cudaEventSynchronize(stop)); + + float milliseconds = 0; + CHECK_CUDA(cudaEventElapsedTime(&milliseconds, start, stop)); + milliseconds /= iters; + +// 6. D2H 拷贝结果 + std::vector<__nv_bfloat16> h_output_bf16; + std::vector h_output_fp16; + if (output_type == OutputType::BF16) { + h_output_bf16.resize(num_elements); + CHECK_CUDA(cudaMemcpy(h_output_bf16.data(), d_output_bf16, num_elements * sizeof(__nv_bfloat16), cudaMemcpyDeviceToHost)); + } else { + h_output_fp16.resize(num_elements); + CHECK_CUDA(cudaMemcpy(h_output_fp16.data(), d_output_fp16, num_elements * sizeof(half), cudaMemcpyDeviceToHost)); + } + +// 7. 计算并打印性能 + double total_io_bytes = static_cast(size_packed + size_absmax_q + size_absmax2 + size_code2) + + static_cast(num_elements * 2); + double bandwidth = total_io_bytes / (milliseconds / 1000.0) / 1e9; + constexpr double bnb_ref_ms = 1.243360; + constexpr double bnb_ref_bw = 543.14; + double speedup_vs_bnb = bnb_ref_ms / static_cast(milliseconds); + double bw_ratio_vs_bnb = bandwidth / bnb_ref_bw; + std::cout << "Kernel Time: " << milliseconds << " ms" << std::endl; + std::cout << "Effective Bandwidth (approx): " << bandwidth << " GB/s" << std::endl; + std::cout << "Speedup vs bitsandbytes: " << speedup_vs_bnb << "x" + << " (ref " << bnb_ref_ms << " ms)" << std::endl; + std::cout << "Bandwidth ratio vs bitsandbytes: " << bw_ratio_vs_bnb << "x" + << " (ref " << bnb_ref_bw << " GB/s)" << std::endl; + std::cout << "Output dtype: " << (output_type == OutputType::BF16 ? "bf16" : "fp16") << std::endl; + +// 8. 写入输出文件 + std::ofstream outfile(output_file, std::ios::binary); + if (output_type == OutputType::BF16) { + outfile.write(reinterpret_cast(h_output_bf16.data()), num_elements * sizeof(__nv_bfloat16)); + } else { + outfile.write(reinterpret_cast(h_output_fp16.data()), num_elements * sizeof(half)); + } + outfile.close(); + std::cout << "Output written to " << output_file << std::endl; + + // 清理 + cudaFree(d_packed); + cudaFree(d_absmax_q); + cudaFree(d_absmax2); + cudaFree(d_code2); + if (d_output_bf16) cudaFree(d_output_bf16); + if (d_output_fp16) cudaFree(d_output_fp16); + cudaEventDestroy(start); + cudaEventDestroy(stop); + + return 0; +} \ No newline at end of file diff --git a/03_nf4_dequant/nf4/ikko/mainla.maca b/03_nf4_dequant/nf4/ikko/mainla.maca new file mode 100644 index 0000000..32e08c7 --- /dev/null +++ b/03_nf4_dequant/nf4/ikko/mainla.maca @@ -0,0 +1,224 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if !defined(PLATFORM_METAX) +#define PLATFORM_METAX +#endif +#include "../tester/utils.h" + +__constant__ float NF4_LUT[16] = { + -1.0f, + -0.6961928009986877f, + -0.5250730514526367f, + -0.39491748809814453f, + -0.28444138169288635f, + -0.18477343022823334f, + -0.09105003625154495f, + 0.0f, + 0.07958029955625534f, + 0.16093020141124725f, + 0.24611230194568634f, + 0.33791524171829224f, + 0.44070982933044434f, + 0.5626170039176941f, + 0.7229568362236023f, + 1.0f +}; + +__global__ void nf4_decode_kernel_fp16( + const uint8_t* __restrict__ packed_weights, + const uint8_t* __restrict__ absmax_q, + const half* __restrict__ absmax2, + const half* __restrict__ code2, + float offset, + half* __restrict__ output, + int64_t num_elements, + int blocksize, + int group_size) { + int64_t tid = static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + int64_t stride = static_cast(gridDim.x) * blockDim.x; + int64_t total_bytes = (num_elements + 1) / 2; + int bytes_per_block = blocksize / 2; + + for (int64_t byte_idx = tid; byte_idx < total_bytes; byte_idx += stride) { + uint8_t packed = packed_weights[byte_idx]; + uint8_t idx_hi = (packed >> 4) & 0x0F; + uint8_t idx_lo = packed & 0x0F; + + int block_id = static_cast(byte_idx / bytes_per_block); + int group_id = block_id / group_size; + + float a2 = __half2float(absmax2[group_id]); + float c2 = __half2float(code2[absmax_q[block_id]]); + float real_absmax = a2 * c2 + offset; + + float v0 = NF4_LUT[idx_hi] * real_absmax; + float v1 = NF4_LUT[idx_lo] * real_absmax; + + int64_t out_idx = byte_idx * 2; + if (out_idx < num_elements) { + output[out_idx] = __float2half(v0); + } + if (out_idx + 1 < num_elements) { + output[out_idx + 1] = __float2half(v1); + } + } +} + +int main(int argc, char** argv) { + std::string input_file = "data/weight_data.bin"; + std::string output_file = "data/output_fp16_maca.bin"; + + if (argc >= 2) { + if (std::strcmp(argv[1], "fp16") != 0) { + std::cerr << "Warning: mainla.maca currently supports fp16 only, got '" << argv[1] + << "'. Continue with fp16 output." << std::endl; + } + } + if (argc >= 3) { + output_file = argv[2]; + } + + std::ifstream infile(input_file, std::ios::binary); + if (!infile) { + char cwd[4096]; + if (getcwd(cwd, sizeof(cwd)) != nullptr) { + std::cerr << "CWD: " << cwd << std::endl; + } + std::cerr << "Error: Cannot open input file: " << input_file << std::endl; + std::string fallback_file = "data/weight_data.bin"; + infile.open(fallback_file, std::ios::binary); + if (!infile) { + std::cerr << "Error: Cannot open fallback input file: " << fallback_file << std::endl; + return 1; + } + input_file = fallback_file; + } + + int64_t num_rows = 0; + int64_t num_cols = 0; + int32_t blocksize = 0; + infile.read(reinterpret_cast(&num_rows), sizeof(int64_t)); + infile.read(reinterpret_cast(&num_cols), sizeof(int64_t)); + infile.read(reinterpret_cast(&blocksize), sizeof(int32_t)); + + std::streampos data_start = infile.tellg(); + infile.seekg(0, std::ios::end); + int64_t file_size = static_cast(infile.tellg()); + infile.seekg(data_start, std::ios::beg); + + int64_t num_elements = num_rows * num_cols; + int64_t num_blocks = (num_elements + blocksize - 1) / blocksize; + + size_t size_packed = static_cast((num_elements + 1) / 2); + size_t size_absmax_q = static_cast(num_blocks) * sizeof(uint8_t); + size_t size_code2 = 256 * sizeof(half); + size_t size_absmax2 = 0; + int64_t num_groups = 0; + + int64_t header_size = static_cast(sizeof(int64_t) * 2 + sizeof(int32_t)); + int64_t remaining = file_size - header_size - + static_cast(size_packed + size_absmax_q + size_code2 + sizeof(float)); + if (remaining > 0 && (remaining % static_cast(sizeof(half)) == 0)) { + num_groups = remaining / static_cast(sizeof(half)); + } else { + num_groups = (num_blocks + 255) / 256; + } + size_absmax2 = static_cast(num_groups) * sizeof(half); + + std::vector h_packed(size_packed); + std::vector h_absmax_q(static_cast(num_blocks)); + std::vector h_absmax2(static_cast(num_groups)); + std::vector h_code2(256); + float offset = 0.0f; + + infile.read(reinterpret_cast(h_packed.data()), size_packed); + infile.read(reinterpret_cast(h_absmax_q.data()), size_absmax_q); + infile.read(reinterpret_cast(h_absmax2.data()), size_absmax2); + infile.read(reinterpret_cast(h_code2.data()), size_code2); + infile.read(reinterpret_cast(&offset), sizeof(float)); + infile.close(); + + uint8_t* d_packed = nullptr; + uint8_t* d_absmax_q = nullptr; + half* d_absmax2 = nullptr; + half* d_code2 = nullptr; + half* d_output = nullptr; + + RUNTIME_CHECK(mcMalloc(&d_packed, size_packed)); + RUNTIME_CHECK(mcMalloc(&d_absmax_q, size_absmax_q)); + RUNTIME_CHECK(mcMalloc(&d_absmax2, size_absmax2)); + RUNTIME_CHECK(mcMalloc(&d_code2, size_code2)); + RUNTIME_CHECK(mcMalloc(&d_output, static_cast(num_elements) * sizeof(half))); + + RUNTIME_CHECK(mcMemcpy(d_packed, h_packed.data(), size_packed, mcMemcpyHostToDevice)); + RUNTIME_CHECK(mcMemcpy(d_absmax_q, h_absmax_q.data(), size_absmax_q, mcMemcpyHostToDevice)); + RUNTIME_CHECK(mcMemcpy(d_absmax2, h_absmax2.data(), size_absmax2, mcMemcpyHostToDevice)); + RUNTIME_CHECK(mcMemcpy(d_code2, h_code2.data(), size_code2, mcMemcpyHostToDevice)); + + dim3 block_dim(256); + int64_t total_bytes = (num_elements + 1) / 2; + int grid_x = 4096; + int64_t max_grid = (total_bytes + block_dim.x - 1) / block_dim.x; + if (grid_x > max_grid) { + grid_x = static_cast(max_grid); + } + if (grid_x < 1) { + grid_x = 1; + } + dim3 grid_dim(grid_x); + + int group_size = static_cast((num_blocks + num_groups - 1) / num_groups); + + nf4_decode_kernel_fp16<<>>( + d_packed, d_absmax_q, d_absmax2, d_code2, offset, d_output, num_elements, blocksize, group_size); + RUNTIME_CHECK(mcGetLastError()); + RUNTIME_CHECK(mcDeviceSynchronize()); + + const int iters = 100; + auto t0 = std::chrono::high_resolution_clock::now(); + for (int i = 0; i < iters; ++i) { + nf4_decode_kernel_fp16<<>>( + d_packed, d_absmax_q, d_absmax2, d_code2, offset, d_output, num_elements, blocksize, group_size); + } + RUNTIME_CHECK(mcGetLastError()); + RUNTIME_CHECK(mcDeviceSynchronize()); + auto t1 = std::chrono::high_resolution_clock::now(); + + double milliseconds = std::chrono::duration(t1 - t0).count() / static_cast(iters); + + std::vector h_output(static_cast(num_elements)); + RUNTIME_CHECK(mcMemcpy(h_output.data(), d_output, static_cast(num_elements) * sizeof(half), mcMemcpyDeviceToHost)); + + double total_io_bytes = static_cast(size_packed + size_absmax_q + size_absmax2 + size_code2) + + static_cast(num_elements * sizeof(half)); + double bandwidth = total_io_bytes / (milliseconds / 1000.0) / 1e9; + + std::cout << "grid_x: " << grid_x << std::endl; + std::cout << "Kernel Time: " << milliseconds << " ms" << std::endl; + std::cout << "Effective Bandwidth (approx): " << bandwidth << " GB/s" << std::endl; + std::cout << "Output dtype: fp16" << std::endl; + + std::ofstream outfile(output_file, std::ios::binary); + outfile.write(reinterpret_cast(h_output.data()), static_cast(num_elements * sizeof(half))); + outfile.close(); + std::cout << "Output written to " << output_file << std::endl; + + RUNTIME_CHECK(mcFree(d_packed)); + RUNTIME_CHECK(mcFree(d_absmax_q)); + RUNTIME_CHECK(mcFree(d_absmax2)); + RUNTIME_CHECK(mcFree(d_code2)); + RUNTIME_CHECK(mcFree(d_output)); + + return 0; +} diff --git a/03_nf4_dequant/nf4/ikko/mainla.mu b/03_nf4_dequant/nf4/ikko/mainla.mu new file mode 100644 index 0000000..bb7b39f --- /dev/null +++ b/03_nf4_dequant/nf4/ikko/mainla.mu @@ -0,0 +1,240 @@ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +__constant__ float NF4_LUT[16] = { + -1.0f, + -0.6961928009986877f, + -0.5250730514526367f, + -0.39491748809814453f, + -0.28444138169288635f, + -0.18477343022823334f, + -0.09105003625154495f, + 0.0f, + 0.07958029955625534f, + 0.16093020141124725f, + 0.24611230194568634f, + 0.33791524171829224f, + 0.44070982933044434f, + 0.5626170039176941f, + 0.7229568362236023f, + 1.0f +}; + +void checkMusa(musaError_t result, const char* func, const char* file, int line) { + if (result != musaSuccess) { + std::cerr << "MUSA error at " << file << ":" << line << " code=" << result << " \"" << func << "\"\n"; + std::cerr << "Error string: " << musaGetErrorString(result) << std::endl; + std::exit(99); + } +} + +#define CHECK_MUSA(val) checkMusa((val), #val, __FILE__, __LINE__) + +__device__ __forceinline__ uint32_t pack_pair_to_u32(float v1, float v2) { + half2 packed = __floats2half2_rn(v1, v2); + return *reinterpret_cast(&packed); +} + +__global__ void nf4_decode_kernel_fp16( + const uint8_t* __restrict__ packed_weights, + const uint8_t* __restrict__ absmax_q, + const half* __restrict__ absmax2, + const half* __restrict__ code2, + float offset, + half* __restrict__ output, + int64_t num_elements, + int blocksize, + int group_size) { + int64_t tid = static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + int64_t stride = static_cast(gridDim.x) * blockDim.x; + int64_t total_bytes = (num_elements + 1) / 2; + int64_t full_pair_bytes = num_elements / 2; + int bytes_per_block = blocksize / 2; + + __shared__ float s_lut[16]; + if (threadIdx.x < 16) { + s_lut[threadIdx.x] = NF4_LUT[threadIdx.x]; + } + __syncthreads(); + + uint32_t* out_u32 = reinterpret_cast(output); + for (int64_t byte_idx = tid; byte_idx < full_pair_bytes; byte_idx += stride) { + uint8_t packed = packed_weights[byte_idx]; + int block_id = static_cast(byte_idx / bytes_per_block); + int group_id = block_id / group_size; + + float real_absmax = __half2float(absmax2[group_id]) * __half2float(code2[absmax_q[block_id]]) + offset; + float v1 = s_lut[packed >> 4] * real_absmax; + float v2 = s_lut[packed & 0x0F] * real_absmax; + out_u32[byte_idx] = pack_pair_to_u32(v1, v2); + } + + if ((num_elements & 1) != 0 && tid == 0) { + int64_t tail_byte = total_bytes - 1; + uint8_t packed = packed_weights[tail_byte]; + int block_id = static_cast(tail_byte / bytes_per_block); + int group_id = block_id / group_size; + float real_absmax = __half2float(absmax2[group_id]) * __half2float(code2[absmax_q[block_id]]) + offset; + output[num_elements - 1] = __float2half(s_lut[packed >> 4] * real_absmax); + } +} + +int main(int argc, char** argv) { + std::string input_file = "data/weight_data.bin"; + std::string output_file = "data/output_fp16_mu.bin"; + + if (argc >= 2) { + if (std::strcmp(argv[1], "fp16") != 0) { + std::cerr << "Warning: mainla.mu currently supports fp16 only, got '" << argv[1] + << "'. Continue with fp16 output." << std::endl; + } + } + if (argc >= 3) { + output_file = argv[2]; + } + + std::ifstream infile(input_file, std::ios::binary); + if (!infile) { + char cwd[4096]; + if (getcwd(cwd, sizeof(cwd)) != nullptr) { + std::cerr << "CWD: " << cwd << std::endl; + } + std::cerr << "Error: Cannot open input file: " << input_file << std::endl; + std::string fallback_file = "data/weight_data.bin"; + infile.open(fallback_file, std::ios::binary); + if (!infile) { + std::cerr << "Error: Cannot open fallback input file: " << fallback_file << std::endl; + return 1; + } + input_file = fallback_file; + } + + int64_t num_rows = 0; + int64_t num_cols = 0; + int32_t blocksize = 0; + infile.read(reinterpret_cast(&num_rows), sizeof(int64_t)); + infile.read(reinterpret_cast(&num_cols), sizeof(int64_t)); + infile.read(reinterpret_cast(&blocksize), sizeof(int32_t)); + + std::streampos data_start = infile.tellg(); + infile.seekg(0, std::ios::end); + int64_t file_size = static_cast(infile.tellg()); + infile.seekg(data_start, std::ios::beg); + + int64_t num_elements = num_rows * num_cols; + int64_t num_blocks = (num_elements + blocksize - 1) / blocksize; + + size_t size_packed = static_cast((num_elements + 1) / 2); + size_t size_packed_padded = (size_packed + 15) & ~static_cast(15); + size_t size_absmax_q = static_cast(num_blocks) * sizeof(uint8_t); + size_t size_code2 = 256 * sizeof(half); + size_t size_absmax2 = 0; + int64_t num_groups = 0; + + int64_t header_size = static_cast(sizeof(int64_t) * 2 + sizeof(int32_t)); + int64_t remaining = file_size - header_size - + static_cast(size_packed + size_absmax_q + size_code2 + sizeof(float)); + if (remaining > 0 && (remaining % static_cast(sizeof(half)) == 0)) { + num_groups = remaining / static_cast(sizeof(half)); + } else { + num_groups = (num_blocks + 255) / 256; + } + size_absmax2 = static_cast(num_groups) * sizeof(half); + + std::vector h_packed(size_packed_padded, 0); + std::vector h_absmax_q(static_cast(num_blocks)); + std::vector h_absmax2(static_cast(num_groups)); + std::vector h_code2(256); + float offset = 0.0f; + + infile.read(reinterpret_cast(h_packed.data()), size_packed); + infile.read(reinterpret_cast(h_absmax_q.data()), size_absmax_q); + infile.read(reinterpret_cast(h_absmax2.data()), size_absmax2); + infile.read(reinterpret_cast(h_code2.data()), size_code2); + infile.read(reinterpret_cast(&offset), sizeof(float)); + infile.close(); + + uint8_t* d_packed = nullptr; + uint8_t* d_absmax_q = nullptr; + half* d_absmax2 = nullptr; + half* d_code2 = nullptr; + half* d_output = nullptr; + + CHECK_MUSA(musaMalloc(&d_packed, size_packed_padded)); + CHECK_MUSA(musaMalloc(&d_absmax_q, size_absmax_q)); + CHECK_MUSA(musaMalloc(&d_absmax2, size_absmax2)); + CHECK_MUSA(musaMalloc(&d_code2, size_code2)); + CHECK_MUSA(musaMalloc(&d_output, static_cast(num_elements) * sizeof(half))); + + CHECK_MUSA(musaMemcpy(d_packed, h_packed.data(), size_packed_padded, musaMemcpyHostToDevice)); + CHECK_MUSA(musaMemcpy(d_absmax_q, h_absmax_q.data(), size_absmax_q, musaMemcpyHostToDevice)); + CHECK_MUSA(musaMemcpy(d_absmax2, h_absmax2.data(), size_absmax2, musaMemcpyHostToDevice)); + CHECK_MUSA(musaMemcpy(d_code2, h_code2.data(), size_code2, musaMemcpyHostToDevice)); + + dim3 block_dim(256); + int64_t total_bytes = (num_elements + 1) / 2; + int grid_x = 4096; + int64_t max_grid = (total_bytes + block_dim.x - 1) / block_dim.x; + if (grid_x > max_grid) { + grid_x = static_cast(max_grid); + } + if (grid_x < 1) { + grid_x = 1; + } + dim3 grid_dim(grid_x); + + int group_size = static_cast((num_blocks + num_groups - 1) / num_groups); + + nf4_decode_kernel_fp16<<>>( + d_packed, d_absmax_q, d_absmax2, d_code2, offset, d_output, num_elements, blocksize, group_size); + CHECK_MUSA(musaGetLastError()); + CHECK_MUSA(musaDeviceSynchronize()); + + const int iters = 100; + auto t0 = std::chrono::high_resolution_clock::now(); + for (int i = 0; i < iters; ++i) { + nf4_decode_kernel_fp16<<>>( + d_packed, d_absmax_q, d_absmax2, d_code2, offset, d_output, num_elements, blocksize, group_size); + } + CHECK_MUSA(musaGetLastError()); + CHECK_MUSA(musaDeviceSynchronize()); + auto t1 = std::chrono::high_resolution_clock::now(); + + double milliseconds = std::chrono::duration(t1 - t0).count() / static_cast(iters); + + std::vector h_output(static_cast(num_elements)); + CHECK_MUSA(musaMemcpy(h_output.data(), d_output, static_cast(num_elements) * sizeof(half), musaMemcpyDeviceToHost)); + + double total_io_bytes = static_cast(size_packed + size_absmax_q + size_absmax2 + size_code2) + + static_cast(num_elements * sizeof(half)); + double bandwidth = total_io_bytes / (milliseconds / 1000.0) / 1e9; + + std::cout << "grid_x: " << grid_x << std::endl; + std::cout << "Kernel Time: " << milliseconds << " ms" << std::endl; + std::cout << "Effective Bandwidth (approx): " << bandwidth << " GB/s" << std::endl; + std::cout << "Output dtype: fp16" << std::endl; + + std::ofstream outfile(output_file, std::ios::binary); + outfile.write(reinterpret_cast(h_output.data()), static_cast(num_elements * sizeof(half))); + outfile.close(); + std::cout << "Output written to " << output_file << std::endl; + + CHECK_MUSA(musaFree(d_packed)); + CHECK_MUSA(musaFree(d_absmax_q)); + CHECK_MUSA(musaFree(d_absmax2)); + CHECK_MUSA(musaFree(d_code2)); + CHECK_MUSA(musaFree(d_output)); + + return 0; +} diff --git a/03_nf4_dequant/nf4/ikko/ncu_report.txt b/03_nf4_dequant/nf4/ikko/ncu_report.txt new file mode 100644 index 0000000..e8b4f03 --- /dev/null +++ b/03_nf4_dequant/nf4/ikko/ncu_report.txt @@ -0,0 +1,5051 @@ +```shell + nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:47, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.29 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,783,921 +    Memory [%]                                                                           %                          83.81 +    DRAM Throughput                                                                      %                          81.81 +    Duration                                                                       usecond                         794.30 +    L1/TEX Cache Throughput                                                              %                          41.80 +    L2 Cache Throughput                                                                  %                          83.81 +    SM Active Cycles                                                                 cycle                   1,707,265.78 +    Compute (SM) [%]                                                                     %                           9.20 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.95 +    Achieved Active Warps Per SM                                                      warp                          35.01 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:47, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.30 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,772,530 +    Memory [%]                                                                           %                          84.35 +    DRAM Throughput                                                                      %                          82.27 +    Duration                                                                       usecond                         789.44 +    L1/TEX Cache Throughput                                                              %                          42.15 +    L2 Cache Throughput                                                                  %                          84.35 +    SM Active Cycles                                                                 cycle                   1,699,883.62 +    Compute (SM) [%]                                                                     %                           9.28 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.93 +    Achieved Active Warps Per SM                                                      warp                          35.01 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:47, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.27 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,767,384 +    Memory [%]                                                                           %                          84.55 +    DRAM Throughput                                                                      %                          82.52 +    Duration                                                                       usecond                         789.34 +    L1/TEX Cache Throughput                                                              %                          42.24 +    L2 Cache Throughput                                                                  %                          84.55 +    SM Active Cycles                                                                 cycle                   1,709,933.30 +    Compute (SM) [%]                                                                     %                           9.30 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.14 +    Achieved Active Warps Per SM                                                      warp                          35.11 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:47, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.16 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,760,429 +    Memory [%]                                                                           %                          84.92 +    DRAM Throughput                                                                      %                          82.83 +    Duration                                                                       usecond                         794.72 +    L1/TEX Cache Throughput                                                              %                          42.43 +    L2 Cache Throughput                                                                  %                          84.92 +    SM Active Cycles                                                                 cycle                   1,705,613.77 +    Compute (SM) [%]                                                                     %                           9.34 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.14 +    Achieved Active Warps Per SM                                                      warp                          35.11 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:47, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.27 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,786,082 +    Memory [%]                                                                           %                          83.68 +    DRAM Throughput                                                                      %                          81.64 +    Duration                                                                       usecond                         797.79 +    L1/TEX Cache Throughput                                                              %                          41.84 +    L2 Cache Throughput                                                                  %                          83.68 +    SM Active Cycles                                                                 cycle                   1,709,916.09 +    Compute (SM) [%]                                                                     %                           9.20 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.02 +    Achieved Active Warps Per SM                                                      warp                          35.05 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:47, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.28 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,782,712 +    Memory [%]                                                                           %                          83.86 +    DRAM Throughput                                                                      %                          81.75 +    Duration                                                                       usecond                         795.97 +    L1/TEX Cache Throughput                                                              %                          41.89 +    L2 Cache Throughput                                                                  %                          83.86 +    SM Active Cycles                                                                 cycle                   1,692,069.59 +    Compute (SM) [%]                                                                     %                           9.22 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.12 +    Achieved Active Warps Per SM                                                      warp                          35.10 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:47, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.25 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,784,529 +    Memory [%]                                                                           %                          83.78 +    DRAM Throughput                                                                      %                          81.78 +    Duration                                                                       usecond                         798.02 +    L1/TEX Cache Throughput                                                              %                          41.74 +    L2 Cache Throughput                                                                  %                          83.78 +    SM Active Cycles                                                                 cycle                   1,695,400.41 +    Compute (SM) [%]                                                                     %                           9.20 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.99 +    Achieved Active Warps Per SM                                                      warp                          35.03 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:47, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.28 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,783,199 +    Memory [%]                                                                           %                          83.85 +    DRAM Throughput                                                                      %                          81.84 +    Duration                                                                       usecond                         795.36 +    L1/TEX Cache Throughput                                                              %                          41.77 +    L2 Cache Throughput                                                                  %                          83.85 +    SM Active Cycles                                                                 cycle                   1,720,274.64 +    Compute (SM) [%]                                                                     %                           9.20 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.11 +    Achieved Active Warps Per SM                                                      warp                          35.09 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.25 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,777,917 +    Memory [%]                                                                           %                          84.16 +    DRAM Throughput                                                                      %                          82.10 +    Duration                                                                       usecond                         794.69 +    L1/TEX Cache Throughput                                                              %                          41.95 +    L2 Cache Throughput                                                                  %                          84.16 +    SM Active Cycles                                                                 cycle                   1,708,117.10 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.06 +    Achieved Active Warps Per SM                                                      warp                          35.07 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.26 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,777,689 +    Memory [%]                                                                           %                          84.21 +    DRAM Throughput                                                                      %                          82.10 +    Duration                                                                       usecond                         794.40 +    L1/TEX Cache Throughput                                                              %                          41.94 +    L2 Cache Throughput                                                                  %                          84.21 +    SM Active Cycles                                                                 cycle                   1,716,964.59 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.75 +    Achieved Active Warps Per SM                                                      warp                          34.92 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.29 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,771,893 +    Memory [%]                                                                           %                          84.42 +    DRAM Throughput                                                                      %                          82.39 +    Duration                                                                       usecond                         789.09 +    L1/TEX Cache Throughput                                                              %                          42.09 +    L2 Cache Throughput                                                                  %                          84.42 +    SM Active Cycles                                                                 cycle                   1,715,996.22 +    Compute (SM) [%]                                                                     %                           9.26 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.97 +    Achieved Active Warps Per SM                                                      warp                          35.02 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.15 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,779,698 +    Memory [%]                                                                           %                          84.02 +    DRAM Throughput                                                                      %                          82.00 +    Duration                                                                       usecond                         803.46 +    L1/TEX Cache Throughput                                                              %                          41.86 +    L2 Cache Throughput                                                                  %                          84.02 +    SM Active Cycles                                                                 cycle                   1,700,522.24 +    Compute (SM) [%]                                                                     %                           9.22 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.87 +    Achieved Active Warps Per SM                                                      warp                          34.98 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.20 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,777,023 +    Memory [%]                                                                           %                          84.16 +    DRAM Throughput                                                                      %                          82.12 +    Duration                                                                       usecond                         798.62 +    L1/TEX Cache Throughput                                                              %                          41.91 +    L2 Cache Throughput                                                                  %                          84.16 +    SM Active Cycles                                                                 cycle                   1,694,419.05 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.21 +    Achieved Active Warps Per SM                                                      warp                          35.14 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.2%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.26 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,778,816 +    Memory [%]                                                                           %                          84.15 +    DRAM Throughput                                                                      %                          82.02 +    Duration                                                                       usecond                         794.91 +    L1/TEX Cache Throughput                                                              %                          41.94 +    L2 Cache Throughput                                                                  %                          84.15 +    SM Active Cycles                                                                 cycle                   1,706,151.49 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.72 +    Achieved Active Warps Per SM                                                      warp                          34.91 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.7%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.12 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,770,841 +    Memory [%]                                                                           %                          84.43 +    DRAM Throughput                                                                      %                          82.41 +    Duration                                                                       usecond                         802.11 +    L1/TEX Cache Throughput                                                              %                          42.09 +    L2 Cache Throughput                                                                  %                          84.43 +    SM Active Cycles                                                                 cycle                   1,708,276.97 +    Compute (SM) [%]                                                                     %                           9.27 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.83 +    Achieved Active Warps Per SM                                                      warp                          34.96 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.13 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,754,791 +    Memory [%]                                                                           %                          85.21 +    DRAM Throughput                                                                      %                          83.03 +    Duration                                                                       usecond                         794.24 +    L1/TEX Cache Throughput                                                              %                          42.49 +    L2 Cache Throughput                                                                  %                          85.21 +    SM Active Cycles                                                                 cycle                   1,711,735.01 +    Compute (SM) [%]                                                                     %                           9.35 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.02 +    Achieved Active Warps Per SM                                                      warp                          35.05 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.15 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,777,220 +    Memory [%]                                                                           %                          84.20 +    DRAM Throughput                                                                      %                          82.12 +    Duration                                                                       usecond                         802.21 +    L1/TEX Cache Throughput                                                              %                          41.91 +    L2 Cache Throughput                                                                  %                          84.20 +    SM Active Cycles                                                                 cycle                   1,704,338.13 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.88 +    Achieved Active Warps Per SM                                                      warp                          34.98 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.33 +    SM Frequency                                                             cycle/nsecond                           2.25 +    Elapsed Cycles                                                                   cycle                      1,782,247 +    Memory [%]                                                                           %                          83.99 +    DRAM Throughput                                                                      %                          81.90 +    Duration                                                                       usecond                         790.78 +    L1/TEX Cache Throughput                                                              %                          41.79 +    L2 Cache Throughput                                                                  %                          83.99 +    SM Active Cycles                                                                 cycle                   1,697,375.76 +    Compute (SM) [%]                                                                     %                           9.21 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.88 +    Achieved Active Warps Per SM                                                      warp                          34.98 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.27 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,774,262 +    Memory [%]                                                                           %                          84.24 +    DRAM Throughput                                                                      %                          82.28 +    Duration                                                                       usecond                         791.65 +    L1/TEX Cache Throughput                                                              %                          42.00 +    L2 Cache Throughput                                                                  %                          84.24 +    SM Active Cycles                                                                 cycle                   1,713,035.62 +    Compute (SM) [%]                                                                     %                           9.25 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.91 +    Achieved Active Warps Per SM                                                      warp                          35.00 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.08 +    SM Frequency                                                             cycle/nsecond                           2.20 +    Elapsed Cycles                                                                   cycle                      1,759,671 +    Memory [%]                                                                           %                          84.97 +    DRAM Throughput                                                                      %                          82.92 +    Duration                                                                       usecond                         799.97 +    L1/TEX Cache Throughput                                                              %                          42.33 +    L2 Cache Throughput                                                                  %                          84.97 +    SM Active Cycles                                                                 cycle                   1,722,472.24 +    Compute (SM) [%]                                                                     %                           9.33 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.00 +    Achieved Active Warps Per SM                                                      warp                          35.04 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.26 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,770,599 +    Memory [%]                                                                           %                          84.53 +    DRAM Throughput                                                                      %                          82.36 +    Duration                                                                       usecond                         790.88 +    L1/TEX Cache Throughput                                                              %                          42.08 +    L2 Cache Throughput                                                                  %                          84.53 +    SM Active Cycles                                                                 cycle                   1,733,918.75 +    Compute (SM) [%]                                                                     %                           9.27 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.54 +    Achieved Active Warps Per SM                                                      warp                          34.82 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.5%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.29 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,784,071 +    Memory [%]                                                                           %                          83.77 +    DRAM Throughput                                                                      %                          81.81 +    Duration                                                                       usecond                         795.04 +    L1/TEX Cache Throughput                                                              %                          41.75 +    L2 Cache Throughput                                                                  %                          83.77 +    SM Active Cycles                                                                 cycle                   1,708,494.95 +    Compute (SM) [%]                                                                     %                           9.20 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.98 +    Achieved Active Warps Per SM                                                      warp                          35.03 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.29 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,774,534 +    Memory [%]                                                                           %                          84.24 +    DRAM Throughput                                                                      %                          82.27 +    Duration                                                                       usecond                         790.30 +    L1/TEX Cache Throughput                                                              %                          42.00 +    L2 Cache Throughput                                                                  %                          84.24 +    SM Active Cycles                                                                 cycle                   1,701,005.85 +    Compute (SM) [%]                                                                     %                           9.25 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.15 +    Achieved Active Warps Per SM                                                      warp                          35.11 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.11 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,764,482 +    Memory [%]                                                                           %                          84.71 +    DRAM Throughput                                                                      %                          82.68 +    Duration                                                                       usecond                         799.65 +    L1/TEX Cache Throughput                                                              %                          42.29 +    L2 Cache Throughput                                                                  %                          84.71 +    SM Active Cycles                                                                 cycle                   1,703,234.04 +    Compute (SM) [%]                                                                     %                           9.30 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.03 +    Achieved Active Warps Per SM                                                      warp                          35.05 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:48, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.09 +    SM Frequency                                                             cycle/nsecond                           2.20 +    Elapsed Cycles                                                                   cycle                      1,763,753 +    Memory [%]                                                                           %                          84.85 +    DRAM Throughput                                                                      %                          82.75 +    Duration                                                                       usecond                         800.99 +    L1/TEX Cache Throughput                                                              %                          42.25 +    L2 Cache Throughput                                                                  %                          84.85 +    SM Active Cycles                                                                 cycle                   1,700,330.09 +    Compute (SM) [%]                                                                     %                           9.30 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.94 +    Achieved Active Warps Per SM                                                      warp                          35.01 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.08 +    SM Frequency                                                             cycle/nsecond                           2.20 +    Elapsed Cycles                                                                   cycle                      1,756,891 +    Memory [%]                                                                           %                          85.16 +    DRAM Throughput                                                                      %                          83.05 +    Duration                                                                       usecond                         798.75 +    L1/TEX Cache Throughput                                                              %                          42.42 +    L2 Cache Throughput                                                                  %                          85.16 +    SM Active Cycles                                                                 cycle                   1,703,631.23 +    Compute (SM) [%]                                                                     %                           9.34 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.07 +    Achieved Active Warps Per SM                                                      warp                          35.07 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.21 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,769,343 +    Memory [%]                                                                           %                          84.57 +    DRAM Throughput                                                                      %                          82.49 +    Duration                                                                       usecond                         793.92 +    L1/TEX Cache Throughput                                                              %                          42.11 +    L2 Cache Throughput                                                                  %                          84.57 +    SM Active Cycles                                                                 cycle                   1,703,819.69 +    Compute (SM) [%]                                                                     %                           9.28 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.73 +    Achieved Active Warps Per SM                                                      warp                          34.91 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.7%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.29 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,783,887 +    Memory [%]                                                                           %                          83.60 +    DRAM Throughput                                                                      %                          81.33 +    Duration                                                                       usecond                         799.68 +    L1/TEX Cache Throughput                                                              %                          41.90 +    L2 Cache Throughput                                                                  %                          83.60 +    SM Active Cycles                                                                 cycle                   1,689,866.03 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.24 +    Achieved Active Warps Per SM                                                      warp                          35.16 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.2%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.19 +    SM Frequency                                                             cycle/nsecond                           2.20 +    Elapsed Cycles                                                                   cycle                      1,765,145 +    Memory [%]                                                                           %                          84.51 +    DRAM Throughput                                                                      %                          82.22 +    Duration                                                                       usecond                         797.95 +    L1/TEX Cache Throughput                                                              %                          42.35 +    L2 Cache Throughput                                                                  %                          84.51 +    SM Active Cycles                                                                 cycle                   1,685,987.81 +    Compute (SM) [%]                                                                     %                           9.32 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.00 +    Achieved Active Warps Per SM                                                      warp                          35.04 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.14 +    SM Frequency                                                             cycle/nsecond                           2.20 +    Elapsed Cycles                                                                   cycle                      1,766,425 +    Memory [%]                                                                           %                          84.65 +    DRAM Throughput                                                                      %                          82.51 +    Duration                                                                       usecond                         799.55 +    L1/TEX Cache Throughput                                                              %                          42.29 +    L2 Cache Throughput                                                                  %                          84.65 +    SM Active Cycles                                                                 cycle                   1,699,142.89 +    Compute (SM) [%]                                                                     %                           9.31 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.99 +    Achieved Active Warps Per SM                                                      warp                          35.03 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.25 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,773,542 +    Memory [%]                                                                           %                          84.23 +    DRAM Throughput                                                                      %                          82.17 +    Duration                                                                       usecond                         793.82 +    L1/TEX Cache Throughput                                                              %                          42.09 +    L2 Cache Throughput                                                                  %                          84.23 +    SM Active Cycles                                                                 cycle                   1,698,140.84 +    Compute (SM) [%]                                                                     %                           9.27 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.03 +    Achieved Active Warps Per SM                                                      warp                          35.06 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.41 +    SM Frequency                                                             cycle/nsecond                           2.26 +    Elapsed Cycles                                                                   cycle                      1,799,017 +    Memory [%]                                                                           %                          83.10 +    DRAM Throughput                                                                      %                          81.05 +    Duration                                                                       usecond                         793.15 +    L1/TEX Cache Throughput                                                              %                          41.52 +    L2 Cache Throughput                                                                  %                          83.10 +    SM Active Cycles                                                                 cycle                   1,704,204.10 +    Compute (SM) [%]                                                                     %                           9.14 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.92 +    Achieved Active Warps Per SM                                                      warp                          35.00 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.11 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,761,121 +    Memory [%]                                                                           %                          84.91 +    DRAM Throughput                                                                      %                          82.89 +    Duration                                                                       usecond                         798.24 +    L1/TEX Cache Throughput                                                              %                          42.30 +    L2 Cache Throughput                                                                  %                          84.91 +    SM Active Cycles                                                                 cycle                   1,713,465.43 +    Compute (SM) [%]                                                                     %                           9.32 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.76 +    Achieved Active Warps Per SM                                                      warp                          34.93 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.21 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,780,830 +    Memory [%]                                                                           %                          84.02 +    DRAM Throughput                                                                      %                          81.93 +    Duration                                                                       usecond                         799.68 +    L1/TEX Cache Throughput                                                              %                          41.86 +    L2 Cache Throughput                                                                  %                          84.02 +    SM Active Cycles                                                                 cycle                   1,705,064.41 +    Compute (SM) [%]                                                                     %                           9.21 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.09 +    Achieved Active Warps Per SM                                                      warp                          35.08 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.21 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,774,889 +    Memory [%]                                                                           %                          84.33 +    DRAM Throughput                                                                      %                          82.19 +    Duration                                                                       usecond                         796.96 +    L1/TEX Cache Throughput                                                              %                          42.00 +    L2 Cache Throughput                                                                  %                          84.33 +    SM Active Cycles                                                                 cycle                   1,702,487.20 +    Compute (SM) [%]                                                                     %                           9.24 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.82 +    Achieved Active Warps Per SM                                                      warp                          34.95 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.17 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,767,706 +    Memory [%]                                                                           %                          84.61 +    DRAM Throughput                                                                      %                          82.50 +    Duration                                                                       usecond                         796.54 +    L1/TEX Cache Throughput                                                              %                          42.15 +    L2 Cache Throughput                                                                  %                          84.61 +    SM Active Cycles                                                                 cycle                   1,717,969.28 +    Compute (SM) [%]                                                                     %                           9.28 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.84 +    Achieved Active Warps Per SM                                                      warp                          34.96 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.15 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,771,567 +    Memory [%]                                                                           %                          84.45 +    DRAM Throughput                                                                      %                          82.40 +    Duration                                                                       usecond                         800.16 +    L1/TEX Cache Throughput                                                              %                          42.11 +    L2 Cache Throughput                                                                  %                          84.45 +    SM Active Cycles                                                                 cycle                   1,699,681.70 +    Compute (SM) [%]                                                                     %                           9.26 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.04 +    Achieved Active Warps Per SM                                                      warp                          35.06 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.29 +    SM Frequency                                                             cycle/nsecond                           2.25 +    Elapsed Cycles                                                                   cycle                      1,782,897 +    Memory [%]                                                                           %                          83.85 +    DRAM Throughput                                                                      %                          81.87 +    Duration                                                                       usecond                         793.95 +    L1/TEX Cache Throughput                                                              %                          41.80 +    L2 Cache Throughput                                                                  %                          83.85 +    SM Active Cycles                                                                 cycle                   1,709,269.09 +    Compute (SM) [%]                                                                     %                           9.20 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.93 +    Achieved Active Warps Per SM                                                      warp                          35.01 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.26 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,773,328 +    Memory [%]                                                                           %                          84.32 +    DRAM Throughput                                                                      %                          82.30 +    Duration                                                                       usecond                         791.87 +    L1/TEX Cache Throughput                                                              %                          42.02 +    L2 Cache Throughput                                                                  %                          84.32 +    SM Active Cycles                                                                 cycle                   1,699,452.32 +    Compute (SM) [%]                                                                     %                           9.25 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.12 +    Achieved Active Warps Per SM                                                      warp                          35.10 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.18 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,763,737 +    Memory [%]                                                                           %                          84.86 +    DRAM Throughput                                                                      %                          82.67 +    Duration                                                                       usecond                         793.79 +    L1/TEX Cache Throughput                                                              %                          42.25 +    L2 Cache Throughput                                                                  %                          84.86 +    SM Active Cycles                                                                 cycle                   1,705,623.02 +    Compute (SM) [%]                                                                     %                           9.30 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.99 +    Achieved Active Warps Per SM                                                      warp                          35.03 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.25 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,776,957 +    Memory [%]                                                                           %                          84.17 +    DRAM Throughput                                                                      %                          81.93 +    Duration                                                                       usecond                         794.66 +    L1/TEX Cache Throughput                                                              %                          41.96 +    L2 Cache Throughput                                                                  %                          84.17 +    SM Active Cycles                                                                 cycle                   1,725,193.72 +    Compute (SM) [%]                                                                     %                           9.24 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.62 +    Achieved Active Warps Per SM                                                      warp                          34.86 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.6%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.20 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,780,655 +    Memory [%]                                                                           %                          84.00 +    DRAM Throughput                                                                      %                          81.97 +    Duration                                                                       usecond                         800.48 +    L1/TEX Cache Throughput                                                              %                          41.84 +    L2 Cache Throughput                                                                  %                          84.00 +    SM Active Cycles                                                                 cycle                   1,714,244.70 +    Compute (SM) [%]                                                                     %                           9.22 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.99 +    Achieved Active Warps Per SM                                                      warp                          35.04 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:49, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.25 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,766,287 +    Memory [%]                                                                           %                          84.69 +    DRAM Throughput                                                                      %                          82.49 +    Duration                                                                       usecond                         789.63 +    L1/TEX Cache Throughput                                                              %                          42.18 +    L2 Cache Throughput                                                                  %                          84.69 +    SM Active Cycles                                                                 cycle                   1,710,521.86 +    Compute (SM) [%]                                                                     %                           9.29 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.80 +    Achieved Active Warps Per SM                                                      warp                          34.94 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.17 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,784,939 +    Memory [%]                                                                           %                          83.73 +    DRAM Throughput                                                                      %                          81.77 +    Duration                                                                       usecond                         804.61 +    L1/TEX Cache Throughput                                                              %                          41.74 +    L2 Cache Throughput                                                                  %                          83.73 +    SM Active Cycles                                                                 cycle                   1,722,849.51 +    Compute (SM) [%]                                                                     %                           9.19 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.07 +    Achieved Active Warps Per SM                                                      warp                          35.07 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.23 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,772,852 +    Memory [%]                                                                           %                          84.32 +    DRAM Throughput                                                                      %                          82.28 +    Duration                                                                       usecond                         794.34 +    L1/TEX Cache Throughput                                                              %                          42.04 +    L2 Cache Throughput                                                                  %                          84.32 +    SM Active Cycles                                                                 cycle                   1,700,840.83 +    Compute (SM) [%]                                                                     %                           9.26 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.17 +    Achieved Active Warps Per SM                                                      warp                          35.12 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.2%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.31 +    SM Frequency                                                             cycle/nsecond                           2.25 +    Elapsed Cycles                                                                   cycle                      1,778,877 +    Memory [%]                                                                           %                          84.04 +    DRAM Throughput                                                                      %                          82.06 +    Duration                                                                       usecond                         790.82 +    L1/TEX Cache Throughput                                                              %                          41.89 +    L2 Cache Throughput                                                                  %                          84.04 +    SM Active Cycles                                                                 cycle                   1,708,369.62 +    Compute (SM) [%]                                                                     %                           9.22 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.13 +    Achieved Active Warps Per SM                                                      warp                          35.10 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.25 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,770,828 +    Memory [%]                                                                           %                          84.53 +    DRAM Throughput                                                                      %                          82.40 +    Duration                                                                       usecond                         791.90 +    L1/TEX Cache Throughput                                                              %                          42.08 +    L2 Cache Throughput                                                                  %                          84.53 +    SM Active Cycles                                                                 cycle                   1,711,479.29 +    Compute (SM) [%]                                                                     %                           9.27 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.04 +    Achieved Active Warps Per SM                                                      warp                          35.06 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.16 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,782,681 +    Memory [%]                                                                           %                          83.96 +    DRAM Throughput                                                                      %                          81.87 +    Duration                                                                       usecond                         803.74 +    L1/TEX Cache Throughput                                                              %                          41.81 +    L2 Cache Throughput                                                                  %                          83.96 +    SM Active Cycles                                                                 cycle                   1,705,371.77 +    Compute (SM) [%]                                                                     %                           9.21 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.97 +    Achieved Active Warps Per SM                                                      warp                          35.03 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.22 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,770,715 +    Memory [%]                                                                           %                          84.45 +    DRAM Throughput                                                                      %                          82.41 +    Duration                                                                       usecond                         793.92 +    L1/TEX Cache Throughput                                                              %                          42.12 +    L2 Cache Throughput                                                                  %                          84.45 +    SM Active Cycles                                                                 cycle                   1,711,417.78 +    Compute (SM) [%]                                                                     %                           9.27 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.13 +    Achieved Active Warps Per SM                                                      warp                          35.10 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.30 +    SM Frequency                                                             cycle/nsecond                           2.25 +    Elapsed Cycles                                                                   cycle                      1,785,654 +    Memory [%]                                                                           %                          83.71 +    DRAM Throughput                                                                      %                          81.77 +    Duration                                                                       usecond                         794.27 +    L1/TEX Cache Throughput                                                              %                          41.75 +    L2 Cache Throughput                                                                  %                          83.71 +    SM Active Cycles                                                                 cycle                   1,722,500.21 +    Compute (SM) [%]                                                                     %                           9.19 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.12 +    Achieved Active Warps Per SM                                                      warp                          35.10 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.15 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,752,615 +    Memory [%]                                                                           %                          85.32 +    DRAM Throughput                                                                      %                          83.20 +    Duration                                                                       usecond                         791.23 +    L1/TEX Cache Throughput                                                              %                          42.51 +    L2 Cache Throughput                                                                  %                          85.32 +    SM Active Cycles                                                                 cycle                   1,701,769.79 +    Compute (SM) [%]                                                                     %                           9.36 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.80 +    Achieved Active Warps Per SM                                                      warp                          34.94 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.31 +    SM Frequency                                                             cycle/nsecond                           2.25 +    Elapsed Cycles                                                                   cycle                      1,777,620 +    Memory [%]                                                                           %                          84.13 +    DRAM Throughput                                                                      %                          82.11 +    Duration                                                                       usecond                         790.46 +    L1/TEX Cache Throughput                                                              %                          41.97 +    L2 Cache Throughput                                                                  %                          84.13 +    SM Active Cycles                                                                 cycle                   1,706,438.66 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.06 +    Achieved Active Warps Per SM                                                      warp                          35.07 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.23 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,775,317 +    Memory [%]                                                                           %                          84.24 +    DRAM Throughput                                                                      %                          82.21 +    Duration                                                                       usecond                         795.23 +    L1/TEX Cache Throughput                                                              %                          41.97 +    L2 Cache Throughput                                                                  %                          84.24 +    SM Active Cycles                                                                 cycle                   1,703,559.45 +    Compute (SM) [%]                                                                     %                           9.24 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.21 +    Achieved Active Warps Per SM                                                      warp                          35.14 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.2%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.20 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,775,640 +    Memory [%]                                                                           %                          84.25 +    DRAM Throughput                                                                      %                          82.19 +    Duration                                                                       usecond                         798.21 +    L1/TEX Cache Throughput                                                              %                          41.98 +    L2 Cache Throughput                                                                  %                          84.25 +    SM Active Cycles                                                                 cycle                   1,697,484.91 +    Compute (SM) [%]                                                                     %                           9.24 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.15 +    Achieved Active Warps Per SM                                                      warp                          35.11 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.2%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.25 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,767,237 +    Memory [%]                                                                           %                          84.64 +    DRAM Throughput                                                                      %                          82.57 +    Duration                                                                       usecond                         790.14 +    L1/TEX Cache Throughput                                                              %                          42.17 +    L2 Cache Throughput                                                                  %                          84.64 +    SM Active Cycles                                                                 cycle                   1,727,770.23 +    Compute (SM) [%]                                                                     %                           9.29 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.89 +    Achieved Active Warps Per SM                                                      warp                          34.99 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.27 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,777,519 +    Memory [%]                                                                           %                          84.18 +    DRAM Throughput                                                                      %                          82.11 +    Duration                                                                       usecond                         793.22 +    L1/TEX Cache Throughput                                                              %                          41.94 +    L2 Cache Throughput                                                                  %                          84.18 +    SM Active Cycles                                                                 cycle                   1,695,667.48 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.26 +    Achieved Active Warps Per SM                                                      warp                          35.16 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.3%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.22 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,778,392 +    Memory [%]                                                                           %                          84.05 +    DRAM Throughput                                                                      %                          82.06 +    Duration                                                                       usecond                         797.98 +    L1/TEX Cache Throughput                                                              %                          41.95 +    L2 Cache Throughput                                                                  %                          84.05 +    SM Active Cycles                                                                 cycle                   1,711,383.60 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.92 +    Achieved Active Warps Per SM                                                      warp                          35.00 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.20 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,773,335 +    Memory [%]                                                                           %                          84.35 +    DRAM Throughput                                                                      %                          82.22 +    Duration                                                                       usecond                         796.54 +    L1/TEX Cache Throughput                                                              %                          42.03 +    L2 Cache Throughput                                                                  %                          84.35 +    SM Active Cycles                                                                 cycle                   1,699,665.90 +    Compute (SM) [%]                                                                     %                           9.25 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.89 +    Achieved Active Warps Per SM                                                      warp                          34.99 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.22 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,774,833 +    Memory [%]                                                                           %                          84.10 +    DRAM Throughput                                                                      %                          81.80 +    Duration                                                                       usecond                         800.38 +    L1/TEX Cache Throughput                                                              %                          42.11 +    L2 Cache Throughput                                                                  %                          84.10 +    SM Active Cycles                                                                 cycle                   1,684,571.45 +    Compute (SM) [%]                                                                     %                           9.28 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.88 +    Achieved Active Warps Per SM                                                      warp                          34.98 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.18 +    SM Frequency                                                             cycle/nsecond                           2.20 +    Elapsed Cycles                                                                   cycle                      1,757,012 +    Memory [%]                                                                           %                          84.84 +    DRAM Throughput                                                                      %                          82.59 +    Duration                                                                       usecond                         795.10 +    L1/TEX Cache Throughput                                                              %                          42.61 +    L2 Cache Throughput                                                                  %                          84.84 +    SM Active Cycles                                                                 cycle                   1,690,701.17 +    Compute (SM) [%]                                                                     %                           9.37 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.93 +    Achieved Active Warps Per SM                                                      warp                          35.01 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.28 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,779,817 +    Memory [%]                                                                           %                          83.94 +    DRAM Throughput                                                                      %                          81.91 +    Duration                                                                       usecond                         794.82 +    L1/TEX Cache Throughput                                                              %                          41.95 +    L2 Cache Throughput                                                                  %                          83.94 +    SM Active Cycles                                                                 cycle                   1,698,823.51 +    Compute (SM) [%]                                                                     %                           9.24 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.78 +    Achieved Active Warps Per SM                                                      warp                          34.94 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:50, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.28 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,777,105 +    Memory [%]                                                                           %                          84.14 +    DRAM Throughput                                                                      %                          82.12 +    Duration                                                                       usecond                         792.96 +    L1/TEX Cache Throughput                                                              %                          42.04 +    L2 Cache Throughput                                                                  %                          84.14 +    SM Active Cycles                                                                 cycle                   1,693,662.16 +    Compute (SM) [%]                                                                     %                           9.25 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.38 +    Achieved Active Warps Per SM                                                      warp                          35.22 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.4%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.32 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,780,194 +    Memory [%]                                                                           %                          83.88 +    DRAM Throughput                                                                      %                          81.86 +    Duration                                                                       usecond                         791.36 +    L1/TEX Cache Throughput                                                              %                          41.98 +    L2 Cache Throughput                                                                  %                          83.88 +    SM Active Cycles                                                                 cycle                   1,698,912.73 +    Compute (SM) [%]                                                                     %                           9.24 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.04 +    Achieved Active Warps Per SM                                                      warp                          35.06 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.30 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,780,258 +    Memory [%]                                                                           %                          83.98 +    DRAM Throughput                                                                      %                          81.91 +    Duration                                                                       usecond                         793.31 +    L1/TEX Cache Throughput                                                              %                          41.95 +    L2 Cache Throughput                                                                  %                          83.98 +    SM Active Cycles                                                                 cycle                   1,718,252.30 +    Compute (SM) [%]                                                                     %                           9.24 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.01 +    Achieved Active Warps Per SM                                                      warp                          35.05 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.32 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,782,033 +    Memory [%]                                                                           %                          83.91 +    DRAM Throughput                                                                      %                          81.82 +    Duration                                                                       usecond                         792.51 +    L1/TEX Cache Throughput                                                              %                          41.89 +    L2 Cache Throughput                                                                  %                          83.91 +    SM Active Cycles                                                                 cycle                   1,694,315.37 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.97 +    Achieved Active Warps Per SM                                                      warp                          35.02 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.16 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,766,427 +    Memory [%]                                                                           %                          84.61 +    DRAM Throughput                                                                      %                          82.63 +    Duration                                                                       usecond                         796.99 +    L1/TEX Cache Throughput                                                              %                          42.18 +    L2 Cache Throughput                                                                  %                          84.61 +    SM Active Cycles                                                                 cycle                   1,682,914.27 +    Compute (SM) [%]                                                                     %                           9.29 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.16 +    Achieved Active Warps Per SM                                                      warp                          35.12 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.2%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.19 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,767,233 +    Memory [%]                                                                           %                          84.65 +    DRAM Throughput                                                                      %                          82.59 +    Duration                                                                       usecond                         794.91 +    L1/TEX Cache Throughput                                                              %                          42.20 +    L2 Cache Throughput                                                                  %                          84.65 +    SM Active Cycles                                                                 cycle                   1,717,799.90 +    Compute (SM) [%]                                                                     %                           9.29 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.81 +    Achieved Active Warps Per SM                                                      warp                          34.95 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.27 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,781,387 +    Memory [%]                                                                           %                          83.98 +    DRAM Throughput                                                                      %                          81.94 +    Duration                                                                       usecond                         794.82 +    L1/TEX Cache Throughput                                                              %                          41.86 +    L2 Cache Throughput                                                                  %                          83.98 +    SM Active Cycles                                                                 cycle                   1,709,151.03 +    Compute (SM) [%]                                                                     %                           9.21 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.82 +    Achieved Active Warps Per SM                                                      warp                          34.96 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.18 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,773,419 +    Memory [%]                                                                           %                          84.36 +    DRAM Throughput                                                                      %                          82.28 +    Duration                                                                       usecond                         798.59 +    L1/TEX Cache Throughput                                                              %                          42.03 +    L2 Cache Throughput                                                                  %                          84.36 +    SM Active Cycles                                                                 cycle                   1,703,497.02 +    Compute (SM) [%]                                                                     %                           9.25 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.92 +    Achieved Active Warps Per SM                                                      warp                          35.00 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.26 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,786,644 +    Memory [%]                                                                           %                          83.67 +    DRAM Throughput                                                                      %                          81.70 +    Duration                                                                       usecond                         798.27 +    L1/TEX Cache Throughput                                                              %                          41.71 +    L2 Cache Throughput                                                                  %                          83.67 +    SM Active Cycles                                                                 cycle                   1,696,600.74 +    Compute (SM) [%]                                                                     %                           9.19 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.06 +    Achieved Active Warps Per SM                                                      warp                          35.07 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.17 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,767,842 +    Memory [%]                                                                           %                          84.64 +    DRAM Throughput                                                                      %                          82.42 +    Duration                                                                       usecond                         796.86 +    L1/TEX Cache Throughput                                                              %                          42.15 +    L2 Cache Throughput                                                                  %                          84.64 +    SM Active Cycles                                                                 cycle                   1,707,926.27 +    Compute (SM) [%]                                                                     %                           9.28 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.02 +    Achieved Active Warps Per SM                                                      warp                          35.05 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.31 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,774,485 +    Memory [%]                                                                           %                          84.06 +    DRAM Throughput                                                                      %                          81.82 +    Duration                                                                       usecond                         792.80 +    L1/TEX Cache Throughput                                                              %                          42.14 +    L2 Cache Throughput                                                                  %                          84.06 +    SM Active Cycles                                                                 cycle                   1,691,359.18 +    Compute (SM) [%]                                                                     %                           9.28 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.83 +    Achieved Active Warps Per SM                                                      warp                          34.96 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.30 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,774,864 +    Memory [%]                                                                           %                          84.07 +    DRAM Throughput                                                                      %                          81.84 +    Duration                                                                       usecond                         793.09 +    L1/TEX Cache Throughput                                                              %                          42.19 +    L2 Cache Throughput                                                                  %                          84.07 +    SM Active Cycles                                                                 cycle                   1,688,350.28 +    Compute (SM) [%]                                                                     %                           9.29 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.86 +    Achieved Active Warps Per SM                                                      warp                          34.97 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.16 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,772,425 +    Memory [%]                                                                           %                          84.42 +    DRAM Throughput                                                                      %                          82.24 +    Duration                                                                       usecond                         799.36 +    L1/TEX Cache Throughput                                                              %                          42.03 +    L2 Cache Throughput                                                                  %                          84.42 +    SM Active Cycles                                                                 cycle                   1,695,587.32 +    Compute (SM) [%]                                                                     %                           9.26 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.98 +    Achieved Active Warps Per SM                                                      warp                          35.03 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.28 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,784,447 +    Memory [%]                                                                           %                          83.49 +    DRAM Throughput                                                                      %                          81.32 +    Duration                                                                       usecond                         800.19 +    L1/TEX Cache Throughput                                                              %                          41.92 +    L2 Cache Throughput                                                                  %                          83.49 +    SM Active Cycles                                                                 cycle                   1,706,873.40 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.03 +    Achieved Active Warps Per SM                                                      warp                          35.06 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.10 +    SM Frequency                                                             cycle/nsecond                           2.18 +    Elapsed Cycles                                                                   cycle                      1,756,646 +    Memory [%]                                                                           %                          84.91 +    DRAM Throughput                                                                      %                          82.62 +    Duration                                                                       usecond                         801.54 +    L1/TEX Cache Throughput                                                              %                          42.61 +    L2 Cache Throughput                                                                  %                          84.91 +    SM Active Cycles                                                                 cycle                   1,689,021.83 +    Compute (SM) [%]                                                                     %                           9.38 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.82 +    Achieved Active Warps Per SM                                                      warp                          34.95 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.02 +    SM Frequency                                                             cycle/nsecond                           2.19 +    Elapsed Cycles                                                                   cycle                      1,757,450 +    Memory [%]                                                                           %                          85.07 +    DRAM Throughput                                                                      %                          82.98 +    Duration                                                                       usecond                         803.68 +    L1/TEX Cache Throughput                                                              %                          42.41 +    L2 Cache Throughput                                                                  %                          85.07 +    SM Active Cycles                                                                 cycle                   1,714,182.38 +    Compute (SM) [%]                                                                     %                           9.34 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.69 +    Achieved Active Warps Per SM                                                      warp                          34.89 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.7%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.16 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,780,359 +    Memory [%]                                                                           %                          84.00 +    DRAM Throughput                                                                      %                          81.89 +    Duration                                                                       usecond                         803.14 +    L1/TEX Cache Throughput                                                              %                          41.91 +    L2 Cache Throughput                                                                  %                          84.00 +    SM Active Cycles                                                                 cycle                   1,689,127.79 +    Compute (SM) [%]                                                                     %                           9.22 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.98 +    Achieved Active Warps Per SM                                                      warp                          35.03 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.25 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,778,013 +    Memory [%]                                                                           %                          84.15 +    DRAM Throughput                                                                      %                          82.09 +    Duration                                                                       usecond                         795.10 +    L1/TEX Cache Throughput                                                              %                          41.93 +    L2 Cache Throughput                                                                  %                          84.15 +    SM Active Cycles                                                                 cycle                   1,710,770.48 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.95 +    Achieved Active Warps Per SM                                                      warp                          35.02 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:51, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.26 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,777,156 +    Memory [%]                                                                           %                          84.19 +    DRAM Throughput                                                                      %                          82.08 +    Duration                                                                       usecond                         793.73 +    L1/TEX Cache Throughput                                                              %                          41.92 +    L2 Cache Throughput                                                                  %                          84.19 +    SM Active Cycles                                                                 cycle                   1,708,096.22 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.09 +    Achieved Active Warps Per SM                                                      warp                          35.09 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.23 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,772,348 +    Memory [%]                                                                           %                          84.26 +    DRAM Throughput                                                                      %                          81.92 +    Duration                                                                       usecond                         798.21 +    L1/TEX Cache Throughput                                                              %                          42.20 +    L2 Cache Throughput                                                                  %                          84.26 +    SM Active Cycles                                                                 cycle                   1,705,450.02 +    Compute (SM) [%]                                                                     %                           9.29 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.10 +    Achieved Active Warps Per SM                                                      warp                          35.09 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.06 +    SM Frequency                                                             cycle/nsecond                           2.18 +    Elapsed Cycles                                                                   cycle                      1,760,523 +    Memory [%]                                                                           %                          84.63 +    DRAM Throughput                                                                      %                          82.44 +    Duration                                                                       usecond                         806.53 +    L1/TEX Cache Throughput                                                              %                          42.47 +    L2 Cache Throughput                                                                  %                          84.63 +    SM Active Cycles                                                                 cycle                   1,708,124.71 +    Compute (SM) [%]                                                                     %                           9.35 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.77 +    Achieved Active Warps Per SM                                                      warp                          34.93 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.21 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,765,081 +    Memory [%]                                                                           %                          84.70 +    DRAM Throughput                                                                      %                          82.69 +    Duration                                                                       usecond                            792 +    L1/TEX Cache Throughput                                                              %                          42.21 +    L2 Cache Throughput                                                                  %                          84.70 +    SM Active Cycles                                                                 cycle                   1,714,362.12 +    Compute (SM) [%]                                                                     %                           9.30 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.92 +    Achieved Active Warps Per SM                                                      warp                          35.00 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.12 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,771,305 +    Memory [%]                                                                           %                          84.49 +    DRAM Throughput                                                                      %                          82.42 +    Duration                                                                       usecond                         801.98 +    L1/TEX Cache Throughput                                                              %                          42.09 +    L2 Cache Throughput                                                                  %                          84.49 +    SM Active Cycles                                                                 cycle                   1,712,171.16 +    Compute (SM) [%]                                                                     %                           9.27 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.82 +    Achieved Active Warps Per SM                                                      warp                          34.95 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.30 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,782,550 +    Memory [%]                                                                           %                          83.71 +    DRAM Throughput                                                                      %                          81.52 +    Duration                                                                       usecond                         796.70 +    L1/TEX Cache Throughput                                                              %                          41.95 +    L2 Cache Throughput                                                                  %                          83.71 +    SM Active Cycles                                                                 cycle                   1,680,424.63 +    Compute (SM) [%]                                                                     %                           9.24 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.19 +    Achieved Active Warps Per SM                                                      warp                          35.13 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.2%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.23 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,766,189 +    Memory [%]                                                                           %                          84.44 +    DRAM Throughput                                                                      %                          82.22 +    Duration                                                                       usecond                         794.82 +    L1/TEX Cache Throughput                                                              %                          42.35 +    L2 Cache Throughput                                                                  %                          84.44 +    SM Active Cycles                                                                 cycle                   1,697,133.87 +    Compute (SM) [%]                                                                     %                           9.32 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.90 +    Achieved Active Warps Per SM                                                      warp                          34.99 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.9%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.19 +    SM Frequency                                                             cycle/nsecond                           2.20 +    Elapsed Cycles                                                                   cycle                      1,771,601 +    Memory [%]                                                                           %                          84.24 +    DRAM Throughput                                                                      %                          81.97 +    Duration                                                                       usecond                         800.58 +    L1/TEX Cache Throughput                                                              %                          42.21 +    L2 Cache Throughput                                                                  %                          84.24 +    SM Active Cycles                                                                 cycle                   1,715,335.30 +    Compute (SM) [%]                                                                     %                           9.30 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.48 +    Achieved Active Warps Per SM                                                      warp                          34.79 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.5%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.21 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,773,845 +    Memory [%]                                                                           %                          84.26 +    DRAM Throughput                                                                      %                          82.21 +    Duration                                                                       usecond                         796.77 +    L1/TEX Cache Throughput                                                              %                          42.09 +    L2 Cache Throughput                                                                  %                          84.26 +    SM Active Cycles                                                                 cycle                   1,714,437.01 +    Compute (SM) [%]                                                                     %                           9.27 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.98 +    Achieved Active Warps Per SM                                                      warp                          35.03 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.27 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,780,810 +    Memory [%]                                                                           %                          83.98 +    DRAM Throughput                                                                      %                          81.89 +    Duration                                                                       usecond                         795.36 +    L1/TEX Cache Throughput                                                              %                          41.91 +    L2 Cache Throughput                                                                  %                          83.98 +    SM Active Cycles                                                                 cycle                   1,699,327.82 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.06 +    Achieved Active Warps Per SM                                                      warp                          35.07 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.17 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,765,811 +    Memory [%]                                                                           %                          84.68 +    DRAM Throughput                                                                      %                          82.59 +    Duration                                                                       usecond                         796.83 +    L1/TEX Cache Throughput                                                              %                          42.32 +    L2 Cache Throughput                                                                  %                          84.68 +    SM Active Cycles                                                                 cycle                   1,711,670.90 +    Compute (SM) [%]                                                                     %                           9.32 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.96 +    Achieved Active Warps Per SM                                                      warp                          35.02 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.26 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,773,499 +    Memory [%]                                                                           %                          84.25 +    DRAM Throughput                                                                      %                          82.22 +    Duration                                                                       usecond                         793.09 +    L1/TEX Cache Throughput                                                              %                          42.07 +    L2 Cache Throughput                                                                  %                          84.25 +    SM Active Cycles                                                                 cycle                   1,685,840.59 +    Compute (SM) [%]                                                                     %                           9.27 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.06 +    Achieved Active Warps Per SM                                                      warp                          35.07 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.36 +    SM Frequency                                                             cycle/nsecond                           2.26 +    Elapsed Cycles                                                                   cycle                      1,792,890 +    Memory [%]                                                                           %                          83.44 +    DRAM Throughput                                                                      %                          81.41 +    Duration                                                                       usecond                         793.34 +    L1/TEX Cache Throughput                                                              %                          41.58 +    L2 Cache Throughput                                                                  %                          83.44 +    SM Active Cycles                                                                 cycle                   1,701,241.52 +    Compute (SM) [%]                                                                     %                           9.16 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.01 +    Achieved Active Warps Per SM                                                      warp                          35.05 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.25 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,780,267 +    Memory [%]                                                                           %                          84.05 +    DRAM Throughput                                                                      %                          81.96 +    Duration                                                                       usecond                         796.26 +    L1/TEX Cache Throughput                                                              %                          41.87 +    L2 Cache Throughput                                                                  %                          84.05 +    SM Active Cycles                                                                 cycle                   1,720,124.72 +    Compute (SM) [%]                                                                     %                           9.22 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          72.80 +    Achieved Active Warps Per SM                                                      warp                          34.95 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (72.8%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.22 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,779,850 +    Memory [%]                                                                           %                          84.00 +    DRAM Throughput                                                                      %                          81.98 +    Duration                                                                       usecond                         798.18 +    L1/TEX Cache Throughput                                                              %                          41.87 +    L2 Cache Throughput                                                                  %                          84.00 +    SM Active Cycles                                                                 cycle                   1,698,645.58 +    Compute (SM) [%]                                                                     %                           9.22 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.24 +    Achieved Active Warps Per SM                                                      warp                          35.16 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.2%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.25 +    SM Frequency                                                             cycle/nsecond                           2.24 +    Elapsed Cycles                                                                   cycle                      1,781,004 +    Memory [%]                                                                           %                          84.03 +    DRAM Throughput                                                                      %                          81.93 +    Duration                                                                       usecond                         796.26 +    L1/TEX Cache Throughput                                                              %                          41.85 +    L2 Cache Throughput                                                                  %                          84.03 +    SM Active Cycles                                                                 cycle                   1,699,534.09 +    Compute (SM) [%]                                                                     %                           9.22 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.13 +    Achieved Active Warps Per SM                                                      warp                          35.10 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.19 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,760,056 +    Memory [%]                                                                           %                          84.93 +    DRAM Throughput                                                                      %                          82.91 +    Duration                                                                       usecond                         791.55 +    L1/TEX Cache Throughput                                                              %                          42.34 +    L2 Cache Throughput                                                                  %                          84.93 +    SM Active Cycles                                                                 cycle                   1,692,582.16 +    Compute (SM) [%]                                                                     %                           9.32 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.04 +    Achieved Active Warps Per SM                                                      warp                          35.06 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.22 +    SM Frequency                                                             cycle/nsecond                           2.21 +    Elapsed Cycles                                                                   cycle                      1,759,875 +    Memory [%]                                                                           %                          84.76 +    DRAM Throughput                                                                      %                          82.60 +    Duration                                                                       usecond                         792.54 +    L1/TEX Cache Throughput                                                              %                          42.47 +    L2 Cache Throughput                                                                  %                          84.76 +    SM Active Cycles                                                                 cycle                   1,690,070.65 +    Compute (SM) [%]                                                                     %                           9.35 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.26 +    Achieved Active Warps Per SM                                                      warp                          35.16 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.3%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.32 +    SM Frequency                                                             cycle/nsecond                           2.23 +    Elapsed Cycles                                                                   cycle                      1,784,241 +    Memory [%]                                                                           %                          83.62 +    DRAM Throughput                                                                      %                          81.39 +    Duration                                                                       usecond                         795.84 +    L1/TEX Cache Throughput                                                              %                          41.93 +    L2 Cache Throughput                                                                  %                          83.62 +    SM Active Cycles                                                                 cycle                   1,682,712.12 +    Compute (SM) [%]                                                                     %                           9.23 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.13 +    Achieved Active Warps Per SM                                                      warp                          35.10 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.1%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:52, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.17 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,763,701 +    Memory [%]                                                                           %                          84.78 +    DRAM Throughput                                                                      %                          82.78 +    Duration                                                                       usecond                         795.14 +    L1/TEX Cache Throughput                                                              %                          42.27 +    L2 Cache Throughput                                                                  %                          84.78 +    SM Active Cycles                                                                 cycle                   1,693,308.48 +    Compute (SM) [%]                                                                     %                           9.31 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.04 +    Achieved Active Warps Per SM                                                      warp                          35.06 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:53, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.20 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,769,207 +    Memory [%]                                                                           %                          84.49 +    DRAM Throughput                                                                      %                          82.51 +    Duration                                                                       usecond                         795.30 +    L1/TEX Cache Throughput                                                              %                          42.11 +    L2 Cache Throughput                                                                  %                          84.49 +    SM Active Cycles                                                                 cycle                   1,704,195.24 +    Compute (SM) [%]                                                                     %                           9.28 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.03 +    Achieved Active Warps Per SM                                                      warp                          35.06 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.0%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy.                                                                                          + +  void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 10:50:53, Context 1, Stream 7 +    Section: GPU Speed Of Light Throughput +    ---------------------------------------------------------------------- --------------- ------------------------------ +    DRAM Frequency                                                           cycle/nsecond                          10.27 +    SM Frequency                                                             cycle/nsecond                           2.22 +    Elapsed Cycles                                                                   cycle                      1,773,060 +    Memory [%]                                                                           %                          84.15 +    DRAM Throughput                                                                      %                          81.88 +    Duration                                                                       usecond                         795.39 +    L1/TEX Cache Throughput                                                              %                          42.17 +    L2 Cache Throughput                                                                  %                          84.15 +    SM Active Cycles                                                                 cycle                   1,699,194.80 +    Compute (SM) [%]                                                                     %                           9.29 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    INF   The kernel is utilizing greater than 80.0% of the available compute or memory performance of the device. To    +          further improve performance, work will likely need to be shifted from the most utilized to another unit.       +          Start by analyzing L2 in the Memory Workload Analysis section.                                                 + +    Section: Launch Statistics +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Size                                                                                                        256 +    Function Cache Configuration                                                                  cudaFuncCachePreferNone +    Grid Size                                                                                                         768 +    Registers Per Thread                                                   register/thread                             32 +    Shared Memory Configuration Size                                                 Kbyte                          16.38 +    Driver Shared Memory Per Block                                             Kbyte/block                           1.02 +    Dynamic Shared Memory Per Block                                             byte/block                              0 +    Static Shared Memory Per Block                                              byte/block                             64 +    Threads                                                                         thread                        196,608 +    Waves Per SM                                                                                                        1 +    ---------------------------------------------------------------------- --------------- ------------------------------ + +    Section: Occupancy +    ---------------------------------------------------------------------- --------------- ------------------------------ +    Block Limit SM                                                                   block                             24 +    Block Limit Registers                                                            block                              8 +    Block Limit Shared Mem                                                           block                             14 +    Block Limit Warps                                                                block                              6 +    Theoretical Active Warps per SM                                                   warp                             48 +    Theoretical Occupancy                                                                %                            100 +    Achieved Occupancy                                                                   %                          73.24 +    Achieved Active Warps Per SM                                                      warp                          35.15 +    ---------------------------------------------------------------------- --------------- ------------------------------ +    WRN   This kernel's theoretical occupancy is not impacted by any block limit. The difference between calculated      +          theoretical (100.0%) and measured achieved occupancy (73.2%) can be the result of warp scheduling overheads    +          or workload imbalances during the kernel execution. Load imbalances can occur between warps within a block     +          as well as across blocks of the same kernel. See the CUDA Best Practices Guide                                 +          (https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#occupancy) for more details on            +          optimizing occupancy. +``` diff --git a/03_nf4_dequant/nf4/ikko/readme.md b/03_nf4_dequant/nf4/ikko/readme.md new file mode 100644 index 0000000..fa489ca --- /dev/null +++ b/03_nf4_dequant/nf4/ikko/readme.md @@ -0,0 +1,891 @@ +## 测试 +make nf4 +make nf4 CUDA_DEVICE=7 +## NF4反量化 +权重 = NF4表值 × (一级scale × 二级scale) + offset +scale = code2[ absmax_q[block] ] × absmax2[group] +w = + NF4_TABLE[q] +× code2[ absmax_q[block] ] +× absmax2[group] ++ offset +关联关系： +Group (16384 weights) + └── 256 Blocks + └── 64 weights + └── 2 per byte +## bitsandbytes参考实现 +```shell +source /data/shared/miniconda3/etc/profile.d/conda.sh && conda activate cuda && python - <<'PY' +import torch +import bitsandbytes as bnb + +rows, cols, blocksize = 16384, 16384, 64 + +# Generate data +x = torch.randn(rows, cols, device='cuda', dtype=torch.bfloat16) +packed, qstate = bnb.functional.quantize_4bit( + x, + blocksize=blocksize, + quant_type='nf4', + compress_statistics=True +) + +# Warmup +for _ in range(5): + y = bnb.functional.dequantize_4bit(packed, qstate, quant_type='nf4', blocksize=blocksize) + +torch.cuda.synchronize() + +# Timing +iters = 100 +start = torch.cuda.Event(enable_timing=True) +stop = torch.cuda.Event(enable_timing=True) +start.record() +for _ in range(iters): + y = bnb.functional.dequantize_4bit(packed, qstate, quant_type='nf4', blocksize=blocksize) +stop.record() +stop.synchronize() + +ms = start.elapsed_time(stop) / iters + +# Approx bandwidth +num_elements = rows * cols +size_packed = num_elements // 2 +num_blocks = (num_elements + blocksize - 1) // blocksize +num_groups = (num_blocks + 255) // 256 +size_absmax_q = num_blocks +size_absmax2 = num_groups * 2 +size_code2 = 256 * 2 +size_out = num_elements * 2 + +total_bytes = size_packed + size_absmax_q + size_absmax2 + size_code2 + size_out +bandwidth = total_bytes / (ms / 1000.0) / 1e9 + +print(f"bitsandbytes dequantize_4bit: {ms:.6f} ms") +print(f"Approx bandwidth: {bandwidth:.2f} GB/s") +PY +``` +bitsandbytes dequantize_4bit: 1.241162 ms +Approx bandwidth: 544.10 GB/s +## 构造标准测试集 + + + + + +## 编写main.cu +### 反量化查表 +来自github bitsandbytes/csrc/kernels.cu +```cpp +__device__ static float fp4_dequantization_lut[8] = { +    0.0f,            // 0b000 +    0.005208333333f, // 0b001 +    0.66666667f,     // 0b010 +    1.0f,            // 0b011 +    0.33333333f,     // 0b100 +    0.5f,            // 0b101 +    0.16666667f,     // 0b110 +    0.25f            // 0b111 +}; + +__device__ static float nf4_dequantization_lut[16] = { +    -1.0f,                 // 0b0000 +    -0.6961928009986877f,  // 0b0001 +    -0.5250730514526367f,  // 0b0010 +    -0.39491748809814453f, // 0b0011 +    -0.28444138169288635f, // 0b0100 +    -0.18477343022823334f, // 0b0101 +    -0.09105003625154495f, // 0b0110 +    0.0f,                  // 0b0111 +    0.07958029955625534f,  // 0b1000 +    0.16093020141124725f,  // 0b1001 +    0.24611230194568634f,  // 0b1010 +    0.33791524171829224f,  // 0b1011 +    0.44070982933044434f,  // 0b1100 +    0.5626170039176941f,   // 0b1101 +    0.7229568362236023f,   // 0b1110 +    1.0f                   // 0b1111 +}; +``` +bitsandbytes使用device，考虑是否使用constant +| 维度 | **device** static | **constant** | +| ------- | ----------------- | ----------------- | +| 存储位置 | Global Memory | Constant Memory | +| 缓存 | L2 / L1 | 专用 Constant Cache | +| Warp 广播 | 无 | 有 | +| 访问延迟 | 高 | 低 | +| 适合 | 普通全局数据 | 查表 / 常量 | +使用constant先。 +### host逻辑 +1.输入解析，读取二进制文件 +2.内存规划 +3.数据加载，分配显存 +4.启动kernel +5.记录性能，写入数据 +### device逻辑 +1. 全局一维线程索引 +2. 读取这 1 个字节，并解包成两个 4-bit 索引 +3. 计算当前字节属于哪一个量化 Block 和 Group +4. 暴力从全局内存 (Global Memory) 读取双重量化参数 +5. 结合 NF4 查表，计算真实的浮点权重 +6. 最朴素的分别写回 (没有使用 Union 向量化合并写入) + +## nativekernel问题解决 +精度远超阈值 +### 解码索引覆盖不足 +最初 grid 维度按 num_groups 计算，实际应按 packed byte 数计算，导致大部分元素没写。 +``` +Kernel Time: 0.121476 ms +Effective Bandwidth (approx): 347.457 GB/s +Output written to nf4/data/output.bin +``` + +### gendata，offset 处理错误 +offset 并非恒为 0，而且应加在 absmax 上，不应加在最终权重上。 +``` +Kernel Time: 0.141412 ms +Effective Bandwidth (approx): 298.473 GB/s +Output written to nf4/data/output.bin +MAE (Mean Absolute Error): 0.000024 +Max Error: 0.031250 +------------------------------ +✅ PASS: MAE (0.000024) is within threshold (0.01) +``` +### 为了可拓展性，使用 Grid-Stride Loops +```cpp +int blockSize = 256; +// 我们根据硬件 SM 数量来决定 grid，或者简单给一个足够大的数 +int numSMs; +cudaDeviceGetAttribute(&numSMs, cudaDevAttrMultiProcessorCount, 0); +int gridSize = 32 * numSMs; // 保证每个 SM 都有活干 +``` +修改代码 +```cpp +int sm_count = 0; + CHECK_CUDA(cudaDeviceGetAttribute(&sm_count, cudaDevAttrMultiProcessorCount, 0)); + int grid_x = sm_count * 4; + int64_t max_grid = (total_bytes + blockDim.x - 1) / blockDim.x; + if (grid_x > max_grid) { + grid_x = static_cast(max_grid); + } + if (grid_x < 1) { + grid_x = 1; + } + dim3 gridDim(grid_x); +``` +此时性能 +``` +Kernel Time: 0.121476 ms +Effective Bandwidth (approx): 347.457 GB/s +``` +换成通用api计算 +```cpp +int sm_count = 0; + CHECK_CUDA(cudaDeviceGetAttribute(&sm_count, cudaDevAttrMultiProcessorCount, 0)); + int grid_x = sm_count * 4; + int64_t max_grid = (total_bytes + blockDim.x - 1) / blockDim.x; + if (grid_x > max_grid) { + grid_x = static_cast(max_grid); + } + if (grid_x < 1) { + grid_x = 1; + } + dim3 gridDim(grid_x); +``` +此时性能 +``` +SM count: 108, max active blocks/SM: 8, grid_x: 864 +Kernel Time: 0.124518 ms +Effective Bandwidth (approx): 338.969 GB/s +Output written to nf4/data/output.bin +``` +## 优化大纲 +1. 向量化访存优化 +```cpp +output[tid * 2] = __float2bfloat16(w1_fp32); + output[tid * 2 + 1] = __float2bfloat16(w2_fp32); +``` +这发起了两次独立的写入，gpu显存控制器可以一次性吃32-bit，64-bit，甚至128-bit的数据 + +2. 冗余计算与重复访存 +blocksize = 64，那么 32 个线程（正好是一个 Warp）处理的 64 个权重，其实都属于同一个 Block。 +3. 整数除法（位运算优化） +4. code2 码表的读取延迟 +## 实际优化 +### 向量化访存 +向量化加载 packed_weights +```cpp +uint8_t packed = packed_weights[byte_idx]; +``` +单字节 load，效率差。GPU 更适合 4B / 8B 对齐访问。 +需注意，主机端对 packed buffer 做 4 字节对齐补零，避免最后一个 uint32 读取越界。 +```cpp +for (int b = 0; b < 4; ++b) { + int64_t byte_idx = word_idx * 4 + b; + if (byte_idx >= total_bytes) { + continue; + } + + uint8_t packed = static_cast((packed_word >> (8 * b)) & 0xFF); + uint8_t idx1 = (packed >> 4) & 0x0F; // 高 4 位对应 output[byte_idx * 2] + uint8_t idx2 = packed & 0x0F; // 低 4 位对应 output[byte_idx * 2 + 1] + + int bytes_per_block = blocksize / 2; + int block_id = static_cast(byte_idx / bytes_per_block); + int group_id = block_id / group_size; + + float a2 = __half2float(absmax2[group_id]); + uint8_t qa = absmax_q[block_id]; + float c2 = __half2float(code2[qa]); + float real_absmax = c2 * a2 + offset; + + float w1_fp32 = NF4_LUT[idx1] * real_absmax; + float w2_fp32 = NF4_LUT[idx2] * real_absmax; + + int64_t out_idx = byte_idx * 2; + if (out_idx < num_elements) { + output[out_idx] = __float2bfloat16(w1_fp32); + } + if (out_idx + 1 < num_elements) { + output[out_idx + 1] = __float2bfloat16(w2_fp32); + } + } +// Kernel Time: 0.172722 ms +// Effective Bandwidth (approx): 244.368 GB/s +``` +#### 读取方式改为 16B 向量化 + +kernel 参数从 const uint32_t* 改为 const uint4* +每线程处理 1 个 16B word（32 个权重），total_words = ceil(total_bytes / 16) +读取 16B 后用 #pragma unroll 在寄存器里拆 16 个 byte，再拆成 32 个 4-bit 索引 +参数只读一次 + +对应这 32 个权重只计算一次 block_id/group_id +只读一次 absmax2/absmax_q/code2/offset，得到 real_absmax，后面 32 个权重复用 +写回向量化 + +每个byte 生成 2 个 bf16，打包成 1 个 uint32 +16 个 uint32 组成 4 个 float4，一次写回 8 个 bf16 +尾部不足 32 权重时走标量写回，避免越界 +主机侧对齐与网格调整 + +packed buffer padding 改为 16B 对齐 +cudaMalloc/cudaMemcpy 使用对齐后的大小 +grid 上限按 total_words 而不是 total_bytes 计算 +#### 此外，精简写回：跳过 float4 强转 +```cpp +out_f4[0] = *reinterpret_cast(&v0); +``` +既然已经拼接好了 uint4，直接用 uint4 类型的指针写回即可。GPU 并不在乎你存入的是 float 还是 uint，只要它是 128 位的。当告诉 GPU 要执行一个存储（Store）操作时，硬件只需要知道两件事： +起始地址（Starting Address）： 数据要写到哪？ +位宽（Bit Width）： 这一趟搬多大的数据（32位、64位还是 128位）？ +当定义一个 uint4 变量并写回时，CUDA 编译器（NVCC）会生成一条类似 STG.E.128 (Store Global 128-bit) 的汇编指令。这条指令不管这 128 位里装的是 8 个 bfloat16、4 个 float，还是 16 个 char。它只负责把寄存器里的 128 个比特流，原封不动地拍到对应的显存地址上。 +### 在native上实现合并写回（无向量访存） +```cpp +if (out_idx + 1 < num_elements) { + Bf16Bits lo; lo.bf = __float2bfloat16(w1_fp32); + Bf16Bits hi; hi.bf = __float2bfloat16(w2_fp32); + out_u32[out_idx / 2] = static_cast(lo.u) | (static_cast(hi.u) << 16); + } else if (out_idx < num_elements) { + output[out_idx] = __float2bfloat16(w1_fp32); + } +Kernel Time: 0.102705 ms +Effective Bandwidth (approx): 410.962 GB/s +``` +## 加载表constant为广播可能conflict +```cpp +__shared__ float s_LUT[16]; + if (threadIdx.x < 16) { + s_LUT[threadIdx.x] = NF4_LUT[threadIdx.x]; + } + __syncthreads(); +``` +搬到 SM（流处理器）内部极其昂贵、速度极快的 Shared Memory（共享内存）中。 +### 更改Shape: 16384x16384, Blocksize: 64 +SM count: 108, max active blocks/SM: 8, grid_x: 864 +Kernel Time: 0.968552 ms +Effective Bandwidth (approx): 697.243 GB/s +------------------------------ +MAE (Mean Absolute Error): 0.000017 +Max Error: 0.031250 +------------------------------ +✅ PASS: MAE (0.000017) is within threshold (0.01) +## 使用inline(编译器优化) +```cpp +__device__ __forceinline__ float nf4_lut_value(uint8_t idx) { + switch (idx & 0x0F) { + case 0x0: return -1.0f; + case 0x1: return -0.6961928009986877f; + case 0x2: return -0.5250730514526367f; + case 0x3: return -0.39491748809814453f; + case 0x4: return -0.28444138169288635f; + case 0x5: return -0.18477343022823334f; + case 0x6: return -0.09105003625154495f; + case 0x7: return 0.0f; + case 0x8: return 0.07958029955625534f; + case 0x9: return 0.16093020141124725f; + case 0xA: return 0.24611230194568634f; + case 0xB: return 0.33791524171829224f; + case 0xC: return 0.44070982933044434f; + case 0xD: return 0.5626170039176941f; + case 0xE: return 0.7229568362236023f; + default: return 1.0f; + } +} +float v1 = nf4_lut_value(p >> 4) * real_absmax; + float v2 = nf4_lut_value(p & 0x0F) * real_absmax; +Kernel Time: 2.58223 ms +Effective Bandwidth (approx): 261.524 GB/s +``` +遂撤回，改为寄存器缓存表值 + + +## 输出适配fp16 +```cpp +template +__device__ __forceinline__ T float_to_out(float v); + +template <> +__device__ __forceinline__ __nv_bfloat16 float_to_out<__nv_bfloat16>(float v) { + return __float2bfloat16(v); +} + +template <> +__device__ __forceinline__ half float_to_out(float v) { + return __float2half(v); +} + +template +__device__ __forceinline__ uint32_t pack_pair_to_u32(float v1, float v2); + +template <> +__device__ __forceinline__ uint32_t pack_pair_to_u32<__nv_bfloat16>(float v1, float v2) { + __nv_bfloat162 packed = __floats2bfloat162_rn(v1, v2); + return *reinterpret_cast(&packed); +} + +template <> +__device__ __forceinline__ uint32_t pack_pair_to_u32(float v1, float v2) { + half2 packed = __floats2half2_rn(v1, v2); + return *reinterpret_cast(&packed); +} +uint32_t u32_val = pack_pair_to_u32(v1, v2); +``` +## 新增加速比，并修改makefile +输出 +```cpp +(cuda) ikko@dsw-607126-85f54bdf75-5lzlx:~/Learning-CUDA$ make nf4 +=== [NF4] Compiling nf4/mainla.cu === +TMPDIR=/home/ikko/Learning-CUDA/.tmp /usr/local/cuda/bin/nvcc -O3 -std=c++17 -arch=sm_80 nf4/mainla.cu -o nf4/mainla +=== [NF4] Running nf4/mainla === +=== CUDA_VISIBLE_DEVICES=7 === +CUDA_VISIBLE_DEVICES=7 ./nf4/mainla +SM count: 108, max active blocks/SM: 8, grid_x: 864 +Kernel Time: 0.968471 ms +Effective Bandwidth (approx): 697.301 GB/s +Speedup vs bitsandbytes: 1.28384x (ref 1.24336 ms) +Bandwidth ratio vs bitsandbytes: 1.28383x (ref 543.14 GB/s) +Output dtype: bf16 +Output written to nf4/data/output.bin +=== [NF4] Verifying MAE === +CUDA_VISIBLE_DEVICES=7 python nf4/verify_mae.py +=== Starting Verification === +Shape: 16384x16384, Blocksize: 64 +------------------------------ +MAE (Mean Absolute Error): 0.000017 +Max Error: 0.031250 +------------------------------ +✅ PASS: MAE (0.000017) is within threshold (0.01) +``` +## 按题目要求回退线程粒度 + +题目要求的是 Packed Store：每个线程一次只处理两个 4-bit 索引，也就是读取 1 个 packed byte，算出 2 个 bf16 后，打包成 1 个 uint32_t，一次性写回全局内存。 +而我前一版做的是：kernel 输入改成 const uint4*，每个线程先读 1 个 uint4，也就是 16 个 byte +16 个 byte 对应 32 个 4-bit 索引 +线程内部虽然也调用了 pack_pair_to_u32(v1, v2) +但那只是线程内部的中间步骤，最终是把 16 个 uint32 再组成 4 个 uint4 写回 +也就是说，之前那版本质上是： +每线程处理 16 个 packed byte +每线程解码 32 个 4-bit 索引 +每线程最终写 4 个 uint4 +这不等于题目要求的： +每线程处理 1 个 packed byte，每线程解码 2 个 4-bit 索引，每线程最终写 1 个 uint32_t。所以这里重新改回严格按题目要求实现。 +```cpp +template +__global__ void nf4_decode_kernel( + const uint8_t* __restrict__ packed_weights, + const uint8_t* __restrict__ absmax_q, + const half* __restrict__ absmax2, + const half* __restrict__ code2, + const float offset, + OutT* __restrict__ output, + int64_t num_elements, + int blocksize, + int group_size +) { + int64_t tid = blockIdx.x * blockDim.x + threadIdx.x; + int64_t stride = gridDim.x * blockDim.x; + int64_t total_bytes = (num_elements + 1) / 2; + int64_t full_pair_bytes = num_elements / 2; + + __shared__ float s_LUT[16]; + if (threadIdx.x < 16) { + s_LUT[threadIdx.x] = NF4_LUT[threadIdx.x]; + } + __syncthreads(); + uint32_t* out_u32 = reinterpret_cast(output); + + for (int64_t byte_idx = tid; byte_idx < full_pair_bytes; byte_idx += stride) { + uint8_t packed = packed_weights[byte_idx]; + int block_id = static_cast(byte_idx / (blocksize / 2)); + int group_id = block_id / group_size; + float real_absmax = (__half2float(absmax2[group_id]) * __half2float(code2[absmax_q[block_id]])) + offset; + float v1 = s_LUT[packed >> 4] * real_absmax; + float v2 = s_LUT[packed & 0x0F] * real_absmax; + out_u32[byte_idx] = pack_pair_to_u32(v1, v2); + } + + if ((num_elements & 1) != 0) { + int64_t tail_byte = total_bytes - 1; + if (tid == 0) { + uint8_t packed = packed_weights[tail_byte]; + int block_id = static_cast(tail_byte / (blocksize / 2)); + int group_id = block_id / group_size; + float real_absmax = (__half2float(absmax2[group_id]) * __half2float(code2[absmax_q[block_id]])) + offset; + output[num_elements - 1] = float_to_out(s_LUT[packed >> 4] * real_absmax); + } + } +} +``` + +同时 host 端的 grid 计算也要跟着改回按 total_bytes 来算，而不是按 total_words 算。因为现在一个线程对应一个 packed byte，不再是一个线程对应一个 uint4。 + +这版的好处是题意完全对齐，线程粒度、处理粒度、写回粒度三者一致。缺点也很明显，性能会比之前那个“每线程吞 16 个 byte”的版本低一些。 + +输出 +```cpp +(cuda) ikko@dsw-607126-85f54bdf75-5lzlx:~/Learning-CUDA$ make nf4 +=== [NF4] Compiling nf4/mainla.cu === +TMPDIR=/home/ikko/Learning-CUDA/.tmp /usr/local/cuda/bin/nvcc -O3 -std=c++17 -arch=sm_80 nf4/mainla.cu -o nf4/mainla +=== [NF4] Running nf4/mainla === +=== CUDA_VISIBLE_DEVICES=7 === +CUDA_VISIBLE_DEVICES=7 ./nf4/mainla +SM count: 108, max active blocks/SM: 8, grid_x: 864 +Kernel Time: 1.95401 ms +Effective Bandwidth (approx): 345.605 GB/s +Speedup vs bitsandbytes: 0.636311x (ref 1.24336 ms) +Bandwidth ratio vs bitsandbytes: 0.636309x (ref 543.14 GB/s) +Output dtype: bf16 +Output written to nf4/data/output.bin +=== [NF4] Verifying MAE === +CUDA_VISIBLE_DEVICES=7 python nf4/verify_mae.py +=== Starting Verification === +Shape: 16384x16384, Blocksize: 64 +------------------------------ +MAE (Mean Absolute Error): 0.000017 +Max Error: 0.031250 +------------------------------ +✅ PASS: MAE (0.000017) is within threshold (0.01) +``` + + +## nsys分析 +```shell +nsys profile --stats=true --force-overwrite=true -o nf4_profile ./nf4/main +``` +输出 +``` +Collecting data... +SM count: 108, max active blocks/SM: 8, grid_x: 864 +Kernel Time: 1.85433 ms +Effective Bandwidth (approx): 364.183 GB/s +Speedup vs bitsandbytes: 0.670517x (ref 1.24336 ms) +Bandwidth ratio vs bitsandbytes: 0.670515x (ref 543.14 GB/s) +Output dtype: bf16 +Output written to nf4/data/output_bf16.bin +Generating '/tmp/nsys-report-aac2.qdstrm' +[1/8] [========================100%] nsys_mainla_bf16.nsys-rep +[2/8] [========================100%] nsys_mainla_bf16.sqlite +[3/8] Executing 'nvtx_sum' stats report +SKIPPED: /home/ikko/Learning-CUDA/nf4/nsys_mainla_bf16.sqlite does not contain NV Tools Extension (NVTX) data. +[4/8] Executing 'osrt_sum' stats report + + Time (%) Total Time (ns) Num Calls Avg (ns) Med (ns) Min (ns) Max (ns) StdDev (ns) Name + -------- --------------- --------- ----------- ----------- --------- --------- ----------- ---------------------- + 58.9 1684692553 24 70195523.0 73322110.5 320037 381847608 79085855.6 poll + 18.6 532343606 1622 328202.0 64362.5 1125 15994793 862809.4 ioctl + 11.3 322412024 31 10400387.9 1856.0 1022 322343688 57894226.3 fclose + 8.1 232039676 1 232039676.0 232039676.0 232039676 232039676 0.0 writev + 2.0 57202734 112 510738.7 2468.0 1002 56702430 5357453.0 fopen + 1.0 28063349 11 2551213.5 1931.0 1007 27199930 8178930.8 read + 0.1 1904289 43 44285.8 10845.0 6238 1058775 159640.8 mmap64 + 0.0 673049 10 67304.9 57184.0 21078 112731 29916.6 sem_timedwait + 0.0 623082 118 5280.4 4386.0 1603 16509 3208.3 open64 + 0.0 306282 2 153141.0 153141.0 139640 166642 19093.3 pthread_create + 0.0 201836 16 12614.8 5748.5 1002 88787 20920.5 mmap + 0.0 82243 1 82243.0 82243.0 82243 82243 0.0 pthread_cond_wait + 0.0 77095 11 7008.6 7257.0 4709 9864 1769.3 write + 0.0 47414 8 5926.8 4498.0 2641 12043 3485.8 munmap + 0.0 32173 3 10724.3 12344.0 6113 13716 4052.0 putc + 0.0 29046 1 29046.0 29046.0 29046 29046 0.0 fgets + 0.0 24664 5 4932.8 4357.0 2220 7422 2186.0 open + 0.0 20110 4 5027.5 4305.5 1200 10299 4042.1 fwrite + 0.0 13228 3 4409.3 3261.0 1894 8073 3245.6 pipe2 + 0.0 11141 2 5570.5 5570.5 5464 5677 150.6 socket + 0.0 9397 2 4698.5 4698.5 1691 7706 4253.2 pthread_cond_broadcast + 0.0 7259 1 7259.0 7259.0 7259 7259 0.0 connect + 0.0 6258 5 1251.6 1244.0 1080 1351 109.6 fcntl + 0.0 4160 1 4160.0 4160.0 4160 4160 0.0 fread + 0.0 2407 1 2407.0 2407.0 2407 2407 0.0 bind + +[5/8] Executing 'cuda_api_sum' stats report + + Time (%) Total Time (ns) Num Calls Avg (ns) Med (ns) Min (ns) Max (ns) StdDev (ns) Name + -------- --------------- --------- ----------- ----------- --------- --------- ----------- ---------------------- + 51.2 277706536 5 55541307.2 1658159.0 5925 272606419 121345975.1 cudaMalloc + 34.5 187258524 1 187258524.0 187258524.0 187258524 187258524 0.0 cudaEventSynchronize + 12.5 67776654 5 13555330.8 1488128.0 63639 51690255 22091691.8 cudaMemcpy + 1.2 6327994 5 1265598.8 1131945.0 20003 2503567 933614.4 cudaFree + 0.6 3056503 1 3056503.0 3056503.0 3056503 3056503 0.0 cudaDeviceSynchronize + 0.1 578595 101 5728.7 4944.0 4228 36734 3821.5 cudaLaunchKernel + 0.0 22548 2 11274.0 11274.0 5889 16659 7615.5 cudaEventRecord + 0.0 17520 2 8760.0 8760.0 762 16758 11310.9 cudaEventDestroy + 0.0 6073 2 3036.5 3036.5 780 5293 3191.2 cudaEventCreate + 0.0 1196 1 1196.0 1196.0 1196 1196 0.0 cuModuleGetLoadingMode + +[6/8] Executing 'cuda_gpu_kern_sum' stats report + + Time (%) Total Time (ns) Instances Avg (ns) Med (ns) Min (ns) Max (ns) StdDev (ns) Name + -------- --------------- --------- --------- -------- -------- -------- ----------- ---------------------------------------------------------------------------------------------------- + 100.0 186128837 101 1842859.8 834756.0 812388 3455505 1258741.2 void nf4_decode_kernel<__nv_bfloat16>(const uint4 *, const unsigned char *, const __half *, const _… + +[7/8] Executing 'cuda_gpu_mem_time_sum' stats report + + Time (%) Total Time (ns) Count Avg (ns) Med (ns) Min (ns) Max (ns) StdDev (ns) Operation + -------- --------------- ----- ---------- ---------- -------- -------- ----------- ---------------------------- + 78.2 51319384 1 51319384.0 51319384.0 51319384 51319384 0.0 [CUDA memcpy Device-to-Host] + 21.8 14291557 4 3572889.3 194241.0 3008 13900067 6887079.2 [CUDA memcpy Host-to-Device] + +[8/8] Executing 'cuda_gpu_mem_size_sum' stats report + + Total (MB) Count Avg (MB) Med (MB) Min (MB) Max (MB) StdDev (MB) Operation + ---------- ----- -------- -------- -------- -------- ----------- ---------------------------- + 536.871 1 536.871 536.871 536.871 536.871 0.000 [CUDA memcpy Device-to-Host] + 138.445 4 34.611 2.114 0.001 134.218 66.433 [CUDA memcpy Host-to-Device] +``` + +## maca +cd /data/Learning-CUDA && mxcc -O3 -std=c++17 nf4/mainla.maca -o nf4/mainla_maca +```cpp +cd /data/Learning-CUDA && mxcc -O3 -std=c++17 nf4/mainla.maca -o nf4/mainla_maca +nf4/mainla.maca:158:19: error: use of undeclared identifier 'macaMalloc'; did you mean 'mcMalloc'? + RUNTIME_CHECK(macaMalloc(&d_packed, size_packed)); + ^~~~~~~~~~ + mcMalloc +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api_template_wrapper.h:6:44: note: 'mcMalloc' declared here +template static inline mcError_t mcMalloc(T **devPtr, size_t size) + ^ +nf4/mainla.maca:159:19: error: use of undeclared identifier 'macaMalloc'; did you mean 'mcMalloc'? + RUNTIME_CHECK(macaMalloc(&d_absmax_q, size_absmax_q)); + ^~~~~~~~~~ + mcMalloc +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api_template_wrapper.h:6:44: note: 'mcMalloc' declared here +template static inline mcError_t mcMalloc(T **devPtr, size_t size) + ^ +nf4/mainla.maca:160:19: error: use of undeclared identifier 'macaMalloc'; did you mean 'mcMalloc'? + RUNTIME_CHECK(macaMalloc(&d_absmax2, size_absmax2)); + ^~~~~~~~~~ + mcMalloc +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api_template_wrapper.h:6:44: note: 'mcMalloc' declared here +template static inline mcError_t mcMalloc(T **devPtr, size_t size) + ^ +nf4/mainla.maca:161:19: error: use of undeclared identifier 'macaMalloc'; did you mean 'mcMalloc'? + RUNTIME_CHECK(macaMalloc(&d_code2, size_code2)); + ^~~~~~~~~~ + mcMalloc +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api_template_wrapper.h:6:44: note: 'mcMalloc' declared here +template static inline mcError_t mcMalloc(T **devPtr, size_t size) + ^ +nf4/mainla.maca:162:19: error: use of undeclared identifier 'macaMalloc'; did you mean 'mcMalloc'? + RUNTIME_CHECK(macaMalloc(&d_output, static_cast(num_elements) * sizeof(half))); + ^~~~~~~~~~ + mcMalloc +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api_template_wrapper.h:6:44: note: 'mcMalloc' declared here +template static inline mcError_t mcMalloc(T **devPtr, size_t size) + ^ +nf4/mainla.maca:164:70: error: use of undeclared identifier 'macaMemcpyHostToDevice' + RUNTIME_CHECK(macaMemcpy(d_packed, h_packed.data(), size_packed, macaMemcpyHostToDevice)); + ^ +nf4/mainla.maca:165:76: error: use of undeclared identifier 'macaMemcpyHostToDevice' + RUNTIME_CHECK(macaMemcpy(d_absmax_q, h_absmax_q.data(), size_absmax_q, macaMemcpyHostToDevice)); + ^ +nf4/mainla.maca:166:73: error: use of undeclared identifier 'macaMemcpyHostToDevice' + RUNTIME_CHECK(macaMemcpy(d_absmax2, h_absmax2.data(), size_absmax2, macaMemcpyHostToDevice)); + ^ +nf4/mainla.maca:167:67: error: use of undeclared identifier 'macaMemcpyHostToDevice' + RUNTIME_CHECK(macaMemcpy(d_code2, h_code2.data(), size_code2, macaMemcpyHostToDevice)); + ^ +nf4/mainla.maca:185:19: error: use of undeclared identifier 'macaGetLastError'; did you mean 'mcGetLastError'? + RUNTIME_CHECK(macaGetLastError()); + ^~~~~~~~~~~~~~~~ + mcGetLastError +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api.h:2311:11: note: 'mcGetLastError' declared here +mcError_t mcGetLastError(void); + ^ +nf4/mainla.maca:186:19: error: use of undeclared identifier 'macaDeviceSynchronize'; did you mean 'mcDeviceSynchronize'? + RUNTIME_CHECK(macaDeviceSynchronize()); + ^~~~~~~~~~~~~~~~~~~~~ + mcDeviceSynchronize +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api.h:570:11: note: 'mcDeviceSynchronize' declared here +mcError_t mcDeviceSynchronize(void); + ^ +nf4/mainla.maca:194:19: error: use of undeclared identifier 'macaGetLastError'; did you mean 'mcGetLastError'? + RUNTIME_CHECK(macaGetLastError()); + ^~~~~~~~~~~~~~~~ + mcGetLastError +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api.h:2311:11: note: 'mcGetLastError' declared here +mcError_t mcGetLastError(void); + ^ +nf4/mainla.maca:195:19: error: use of undeclared identifier 'macaDeviceSynchronize'; did you mean 'mcDeviceSynchronize'? + RUNTIME_CHECK(macaDeviceSynchronize()); + ^~~~~~~~~~~~~~~~~~~~~ + mcDeviceSynchronize +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api.h:570:11: note: 'mcDeviceSynchronize' declared here +mcError_t mcDeviceSynchronize(void); + ^ +nf4/mainla.maca:201:107: error: use of undeclared identifier 'macaMemcpyDeviceToHost' + RUNTIME_CHECK(macaMemcpy(h_output.data(), d_output, static_cast(num_elements) * sizeof(half), macaMemcpyDeviceToHost)); + ^ +nf4/mainla.maca:217:19: error: use of undeclared identifier 'macaFree'; did you mean 'mcFree'? + RUNTIME_CHECK(macaFree(d_packed)); + ^~~~~~~~ + mcFree +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api.h:2609:11: note: 'mcFree' declared here +mcError_t mcFree(void *ptr); + ^ +nf4/mainla.maca:218:19: error: use of undeclared identifier 'macaFree'; did you mean 'mcFree'? + RUNTIME_CHECK(macaFree(d_absmax_q)); + ^~~~~~~~ + mcFree +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api.h:2609:11: note: 'mcFree' declared here +mcError_t mcFree(void *ptr); + ^ +nf4/mainla.maca:219:19: error: use of undeclared identifier 'macaFree'; did you mean 'mcFree'? + RUNTIME_CHECK(macaFree(d_absmax2)); + ^~~~~~~~ + mcFree +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api.h:2609:11: note: 'mcFree' declared here +mcError_t mcFree(void *ptr); + ^ +nf4/mainla.maca:220:19: error: use of undeclared identifier 'macaFree'; did you mean 'mcFree'? + RUNTIME_CHECK(macaFree(d_code2)); + ^~~~~~~~ + mcFree +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api.h:2609:11: note: 'mcFree' declared here +mcError_t mcFree(void *ptr); + ^ +nf4/mainla.maca:221:19: error: use of undeclared identifier 'macaFree'; did you mean 'mcFree'? + RUNTIME_CHECK(macaFree(d_output)); + ^~~~~~~~ + mcFree +nf4/../tester/utils.h:29:28: note: expanded from macro 'RUNTIME_CHECK' + RUNTIME_ERR_TYPE err = call; \ + ^ +/opt/maca/include/mcr/mc_runtime_api.h:2609:11: note: 'mcFree' declared here +mcError_t mcFree(void *ptr); + ^ +19 errors generated when compiling for host. +``` +原来沐曦用的是mc而不是maca + + +## ncu + +4090上ncu的结果 +```shell +sudo ncu \ + --section SpeedOfLight \ + --section MemoryWorkloadAnalysis \ + --launch-skip 1 \ + --launch-count 1 \ + ./nf4/mainla bf16 +``` +拿到的关键信息大致是： + • DRAM Throughput ≈ 83% + • Memory ≈ 83% + • Compute (SM) ≈ 38% ~ 42% + • Memory Throughput ≈ 816 ~ 824 GB/s + • L2 Hit Rate ≈ 79.84% +说明 1. 这个 kernel 已经明显是 memory-bound； + 2. 不是算力没吃满，而是 DRAM 带宽已经被压得比较高； + 3. 继续优化如果不动访存主路径，很难有大提升。 + +```shell +sudo ncu \ + --section SchedulerStats \ + --section WarpStateStats \ + --launch-skip 1 \ + --launch-count 1 \ + ./nf4/mainla bf16 +==PROF== Connected to process 810279 (/home/xjy/Learning-CUDA/nf4/mainla) +SM count: 128, max active blocks/SM: 6, grid_x: 768 +==PROF== Profiling "nf4_decode_kernel" - 0 (1/1): 0%....50%....100% - 8 passes +Kernel Time: 2.01215 ms +Effective Bandwidth (approx): 335.62 GB/s +Speedup vs bitsandbytes: 0.617927x (ref 1.24336 ms) +Bandwidth ratio vs bitsandbytes: 0.617925x (ref 543.14 GB/s) +Output dtype: bf16 +Output written to nf4/data/output_bf16.bin +==PROF== Disconnected from process 810279 +[810279] mainla@127.0.0.1 + void nf4_decode_kernel<__nv_bfloat16>(const unsigned char *, const unsigned char *, const __half *, const __half *, float, T1 *, long, int, int), 2026-Mar-10 14:16:43, Context 1, Stream 7 + Section: Scheduler Statistics + ---------------------------------------------------------------------- --------------- ------------------------------ + One or More Eligible % 42.23 + Issued Warp Per Scheduler 0.42 + No Eligible % 57.77 + Active Warps Per Scheduler warp 12.08 + Eligible Warps Per Scheduler warp 1.11 + ---------------------------------------------------------------------- --------------- ------------------------------ + WRN Every scheduler is capable of issuing one instruction per cycle, but for this kernel each scheduler only + issues an instruction every 2.4 cycles. This might leave hardware resources underutilized and may lead to + less optimal performance. Out of the maximum of 12 warps per scheduler, this kernel allocates an average of + 12.08 active warps per scheduler, but only an average of 1.11 warps were eligible per cycle. Eligible warps + are the subset of active warps that are ready to issue their next instruction. Every cycle with no eligible + warp results in no instruction being issued and the issue slot remains unused. To increase the number of + eligible warps, avoid possible load imbalances due to highly different execution durations per warp. + Reducing stalls indicated on the Warp State Statistics and Source Counters sections can help, too. + + Section: Warp State Statistics + ---------------------------------------------------------------------- --------------- ------------------------------ + Warp Cycles Per Issued Instruction cycle 28.61 + Warp Cycles Per Executed Instruction cycle 28.61 + Avg. Active Threads Per Warp 19.67 + Avg. Not Predicated Off Threads Per Warp 18.16 + ---------------------------------------------------------------------- --------------- ------------------------------ + WRN On average, each warp of this kernel spends 19.0 cycles being stalled waiting for a scoreboard dependency on + a L1TEX (local, global, surface, texture, rtcore) operation. This represents about 66.5% of the total + average of 28.6 cycles between issuing two instructions. To reduce the number of cycles waiting on L1TEX + data accesses verify the memory access patterns are optimal for the target architecture, attempt to increase + cache hit rates by increasing data locality or by changing the cache configuration, and consider moving + frequently used data to registers and to shared memory. + ----- -------------------------------------------------------------------------------------------------------------- + INF Check the Source Counters section for the top stall locations in your source based on sampling data. The + Kernel Profiling Guide (https://docs.nvidia.com/nsight-compute/ProfilingGuide/index.html#sampling) provides + more details on each stall reason. + ----- -------------------------------------------------------------------------------------------------------------- + WRN Instructions are executed in warps, which are groups of 32 threads. Optimal instruction throughput is + achieved if all 32 threads of a warp execute the same instruction. The chosen launch configuration, early + thread completion, and divergent flow control can significantly lower the number of active threads in a warp + per cycle. This kernel achieves an average of 19.7 threads being active per cycle. This is further reduced + to 18.2 threads per warp due to predication. The compiler may use predication to avoid an actual branch. + Instead, all instructions are scheduled, but a per-thread condition code or predicate controls which threads + execute the instructions. Try to avoid different execution paths within a warp when possible. In addition, + ensure your kernel makes use of Independent Thread Scheduling, which allows a warp to reconverge after a + data-dependent conditional block by explicitly calling __syncwarp(). +``` +不是抽象地 memory-bound，而是 大量 warp 在等 L1TEX 路径上的 load 返回；调度器手上虽然挂了很多 warp，但真正能随时发射的 warp 很少；所以 issue slot 经常空着。 +怀疑：1.不只是主数据流 packed_weights 在拖； +2.absmax_q / absmax2 / code2 这些访问也可能形成依赖链； +3.另外，热路径里的整数计算（特别是除法）可能在吃性能。 +### blocksize,group_size +printf("group_size: %d,block_size: %d",group_size,blocksize); +得到block_size: 64；group_size:256 +```cpp +float real_absmax = 0.0f; + if (lane == 0) { + uint8_t qa = absmax_q[block_id]; + real_absmax = (__half2float(absmax2[group_id]) * __half2float(code2[qa])) + offset; + } + real_absmax = __shfl_sync(warp_mask, real_absmax, 0); +``` +没啥变化 +可能code2 / absmax2 这种小数据本来就可能已经被 cache 命中；新加的 if (lane == 0) 和 __shfl_sync 也有额外开销。 + +综上 +综合几轮 NCU，我目前对这个 kernel 的判断是： + +已经确认的事实 + 1. 它是明显的 memory-bound kernel； + 2. DRAM 带宽已经吃到比较高； + 3. warp 大量 stall 在 L1TEX scoreboard dependency 上； + 4. shared LUT 在我的测试里更快，应该保留； + 5. real_absmax 的 warp 广播不是主收益点； + 6. 热路径里的运行时除法是一个更值得优先处理的问题。 + +热路径的主要成本大概来自： +主成本 + • packed_weights[byte_idx] 的 load + • out_u32[byte_idx] 的 store +次成本 + • absmax_q[block_id] + • absmax2[group_id] + • code2[qa] +可能被低估的成本 + • byte_idx / (blocksize / 2) + • block_id / group_size + +## 由于A100显存占用 +最终在4090测试。 +结果：rows=16384, cols=16384, blocksize=64 +```shell +./nf4/mainla +SM count: 128, max active blocks/SM: 6, grid_x: 768 +Kernel Time: 0.790252 ms +Effective Bandwidth (approx): 854.559 GB/s +Speedup vs bitsandbytes: 1.57337x (ref 1.24336 ms) +Bandwidth ratio vs bitsandbytes: 1.57337x (ref 543.14 GB/s) +Output dtype: bf16 +Output written to nf4/data/output.bin +``` +rows=24576, cols=24576, blocksize=64 +```shell +./nf4/mainla +SM count: 128, max active blocks/SM: 6, grid_x: 768 +Kernel Time: 1.77564 ms +Effective Bandwidth (approx): 855.727 GB/s +Speedup vs bitsandbytes: 0.700233x (ref 1.24336 ms) +Bandwidth ratio vs bitsandbytes: 1.57552x (ref 543.14 GB/s) +Output dtype: bf16 +Output written to nf4/data/output.bin +``` \ No newline at end of file diff --git a/03_nf4_dequant/nf4/ikko/testbit.py b/03_nf4_dequant/nf4/ikko/testbit.py new file mode 100644 index 0000000..eeb86bd --- /dev/null +++ b/03_nf4_dequant/nf4/ikko/testbit.py @@ -0,0 +1,93 @@ +import torch +import bitsandbytes.functional as F + + +def main(): + assert torch.cuda.is_available(), "CUDA" + + device = "cuda" + + # ========================= + # 测试规模 + # ========================= + rows = 16384 + cols = 16384 + blocksize = 64 + repeat = 10 + + print("=== 4bit Dequant Bandwidth Test ===") + + # ========================= + # 构造数据 + # ========================= + x = torch.randn( + rows, + cols, + device=device, + dtype=torch.float16 + ) + + # 4bit 量化 + q_weight, state = F.quantize_4bit( + x, + blocksize=blocksize, + compress_statistics=True + ) + + numel = q_weight.numel() + + # ========================= + # 预热 + # ========================= + for _ in range(3): + F.dequantize_4bit(q_weight, state) + + torch.cuda.synchronize() + + # ========================= + # CUDA 计时 + # ========================= + start = torch.cuda.Event(True) + end = torch.cuda.Event(True) + + start.record() + + for _ in range(repeat): + y = F.dequantize_4bit(q_weight, state) + + end.record() + torch.cuda.synchronize() + + elapsed_ms = start.elapsed_time(end) + + # ========================= + # 带宽估算 + # ========================= + + # 读取： + # 1. 4bit weight: 0.5 byte + # 2. absmax (fp16): 2 byte + # + # 写入： + # 3. fp16 output: 2 byte + + bytes_read = numel * 0.5 + numel * 2 + bytes_write = numel * 2 + + total_bytes = (bytes_read + bytes_write) * repeat + + seconds = elapsed_ms / 1000.0 + + gbps = total_bytes / seconds / 1e9 + + # ========================= + # 输出 + # ========================= + print(f"Matrix: {rows} x {cols}") + print(f"Repeat: {repeat}") + print(f"Time: {elapsed_ms:.3f} ms") + print(f"Bandwidth: {gbps:.2f} GB/s") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/03_nf4_dequant/nf4/ikko/verify_mae.py b/03_nf4_dequant/nf4/ikko/verify_mae.py new file mode 100644 index 0000000..23da03f --- /dev/null +++ b/03_nf4_dequant/nf4/ikko/verify_mae.py @@ -0,0 +1,85 @@ +import torch +import numpy as np +import os +import struct + +def check_mae(output_dir="03_nf4_dequant/nf4/ikko/data", cuda_output_file="03_nf4_dequant/nf4/ikko/data/output.bin"): + truth_file = os.path.join(output_dir, "ground_truth.bin") + input_file = os.path.join(output_dir, "weight_data.bin") + + print("=== Starting Verification ===") + + # 1. 读取元数据以确定形状 (从输入文件读) + with open(input_file, "rb") as f: + # 读取前 20 字节 (rows:8, cols:8, blocksize:4) + header = f.read(20) + rows, cols, blocksize = struct.unpack("qqi", header) + + print(f"Shape: {rows}x{cols}, Blocksize: {blocksize}") + + # 2. 读取官方 Ground Truth + # 假设它是 BF16 格式 (numpy 不直接支持 bf16，通常视具体情况处理) + # 这里我们用 pytorch 读取，因为它支持 bf16 + with open(truth_file, "rb") as f: + truth_bytes = f.read() + # 将字节流转为 Tensor + # 注意：Python 的 torch.frombuffer 可能会由于字节对齐问题报错，这里使用 numpy view 变通 + # (由于 numpy 无 bf16，我们假设文件存储的是原生字节，用 int16 读取再转 torch.bfloat16) + truth_np = np.frombuffer(truth_bytes, dtype=np.int16).copy().reshape(rows, cols) + truth_tensor = torch.from_numpy(truth_np).view(torch.bfloat16).float() # 转为 float32 用于计算 MAE + + # 3. 读取你的 CUDA Kernel 输出 + candidates = [ + cuda_output_file, + os.path.join(output_dir, cuda_output_file), + os.path.join(output_dir, "output.bin"), + "output.bin", + ] + unique_candidates = [] + for path in candidates: + if path not in unique_candidates: + unique_candidates.append(path) + + cuda_path = None + for path in unique_candidates: + if os.path.exists(path): + cuda_path = path + break + + if cuda_path is None: + print(f"Error: CUDA output file not found. Tried: {unique_candidates}") + return + + with open(cuda_path, "rb") as f: + cuda_bytes = f.read() + + # 检查文件大小是否匹配 + expected_size = rows * cols * 2 # BF16 = 2 bytes + if len(cuda_bytes) != expected_size: + print(f"Error: Output size mismatch! Expected {expected_size}, got {len(cuda_bytes)}") + return + + cuda_np = np.frombuffer(cuda_bytes, dtype=np.int16).copy().reshape(rows, cols) + cuda_tensor = torch.from_numpy(cuda_np).view(torch.bfloat16).float() + + # 4. 计算 MAE (Mean Absolute Error) + diff = torch.abs(truth_tensor - cuda_tensor) + mae = torch.mean(diff).item() + + # 计算最大误差 + max_diff = torch.max(diff).item() + + print("-" * 30) + print(f"MAE (Mean Absolute Error): {mae:.6f}") + print(f"Max Error: {max_diff:.6f}") + print("-" * 30) + + # 5. 判定标准 + threshold = 1e-2 + if mae < threshold: + print(f"✅ PASS: MAE ({mae:.6f}) is within threshold ({threshold})") + else: + print(f"❌ FAIL: MAE ({mae:.6f}) exceeds threshold ({threshold})") + +if __name__ == "__main__": + check_mae() \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..5228d6f --- /dev/null +++ b/Makefile @@ -0,0 +1,21 @@ +CUDA_DEVICE ?= 0 +PYTHON ?= python + +NF4_DIR := 03_nf4_dequant/nf4/ikko +NF4_CU := $(NF4_DIR)/mainla.cu +NF4_BIN := $(NF4_DIR)/mainla +NF4_VERIFY := $(NF4_DIR)/verify_mae.py +NF4_OUTPUT := $(NF4_DIR)/data/output.bin + +.PHONY: nf4 + +# NF4 one-command pipeline: compile + run + verify +nf4: + @echo "=== [NF4] Compiling $(NF4_CU) ===" + @mkdir -p .tmp + TMPDIR=$(CURDIR)/.tmp /usr/local/cuda/bin/nvcc -O3 -std=c++17 -arch=sm_80 $(NF4_CU) -o $(NF4_BIN) + @echo "=== [NF4] Running $(NF4_BIN) ===" + @echo "=== CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) ===" + CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) ./$(NF4_BIN) bf16 $(NF4_OUTPUT) + @echo "=== [NF4] Verifying MAE ===" + CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) $(PYTHON) $(NF4_VERIFY) From eb9f79c3f846edbf1307e6ebb7434e41b00d92d5 Mon Sep 17 00:00:00 2001 From: ikko-debug <862049654@qq.com> Date: Sun, 15 Mar 2026 01:05:45 +0800 Subject: [PATCH 2/3] add nf4 dequant project by ikko2 --- 03_nf4_dequant/{nf4 => }/ikko/gen_data.py | 2 +- 03_nf4_dequant/{nf4 => }/ikko/main.cu | 0 03_nf4_dequant/{nf4 => }/ikko/mainla | Bin 1039056 -> 1039056 bytes 03_nf4_dequant/{nf4 => }/ikko/mainla.cu | 10 ++--- 03_nf4_dequant/{nf4 => }/ikko/mainla.maca | 6 +-- 03_nf4_dequant/{nf4 => }/ikko/mainla.mu | 6 +-- 03_nf4_dequant/{nf4 => }/ikko/ncu_report.txt | 0 03_nf4_dequant/{nf4 => }/ikko/readme.md | 23 +++++++++++ 03_nf4_dequant/{nf4 => }/ikko/testbit.py | 0 03_nf4_dequant/{nf4 => }/ikko/verify_mae.py | 2 +- Makefile | 40 +++++++++++++++++-- 11 files changed, 72 insertions(+), 17 deletions(-) rename 03_nf4_dequant/{nf4 => }/ikko/gen_data.py (98%) rename 03_nf4_dequant/{nf4 => }/ikko/main.cu (100%) rename 03_nf4_dequant/{nf4 => }/ikko/mainla (87%) rename 03_nf4_dequant/{nf4 => }/ikko/mainla.cu (97%) rename 03_nf4_dequant/{nf4 => }/ikko/mainla.maca (97%) rename 03_nf4_dequant/{nf4 => }/ikko/mainla.mu (97%) rename 03_nf4_dequant/{nf4 => }/ikko/ncu_report.txt (100%) rename 03_nf4_dequant/{nf4 => }/ikko/readme.md (98%) rename 03_nf4_dequant/{nf4 => }/ikko/testbit.py (100%) rename 03_nf4_dequant/{nf4 => }/ikko/verify_mae.py (96%) diff --git a/03_nf4_dequant/nf4/ikko/gen_data.py b/03_nf4_dequant/ikko/gen_data.py similarity index 98% rename from 03_nf4_dequant/nf4/ikko/gen_data.py rename to 03_nf4_dequant/ikko/gen_data.py index d51b941..b894d47 100644 --- a/03_nf4_dequant/nf4/ikko/gen_data.py +++ b/03_nf4_dequant/ikko/gen_data.py @@ -4,7 +4,7 @@ import os import numpy as np -def generate_inputs(rows=16384, cols=16384, blocksize=64, output_dir="03_nf4_dequant/nf4/ikko/data", compute_type="bf16"): +def generate_inputs(rows=16384, cols=16384, blocksize=64, output_dir="03_nf4_dequant/ikko/data", compute_type="bf16"): os.makedirs(output_dir, exist_ok=True) compute_type = compute_type.lower() diff --git a/03_nf4_dequant/nf4/ikko/main.cu b/03_nf4_dequant/ikko/main.cu similarity index 100% rename from 03_nf4_dequant/nf4/ikko/main.cu rename to 03_nf4_dequant/ikko/main.cu diff --git a/03_nf4_dequant/nf4/ikko/mainla b/03_nf4_dequant/ikko/mainla similarity index 87% rename from 03_nf4_dequant/nf4/ikko/mainla rename to 03_nf4_dequant/ikko/mainla index ad85050411723f5c98bb2f7bc92c620f8a358f54..62abc8597380347426f054300bfc7dd505ef6bdc 100755 GIT binary patch delta 35553 zcmZ{s33yFc)c5bbFMl6OwCa$trn@Os4+HHbRsAz zN>U{;C#I$-i54*@sHVom7)pI>oxRTce0ROym*;8!*8jKH+WYJ~=R(-cA9R*6WXndS*PRb?Ta z#nfKeeVr>+G14teLj>Ke{2DsTWiyRYu??Lns-d^*K08Tb{BsqL~y_$L?3UMpiNXT(vD2y1btUUBOS>!MbH^45$STKd4g_G zSx65swO4gt)df}D*ctwSX^5Z|j_TD$2;a$mjPUEK$R0kA+BnVoI{WZc5WIsdrJybHz zHH>MYpm8eq4d=3^c88DCeTmzZwW-r}lGDNjy{&?qI>TQujT6)-TQ7a7@MCP{jJKH- z;U}m>oU0{gOpIK>CttfXjW&la(XL>GJta?^2YY%~UAT-b@n&9jRiGe#$gM z&?J?NG}A-xbD^O5Di^7}l%_t_-B%T$tiev#Dy|$R=w=m+bU)KLLGx5J(lD-^BIpB^ zh}83#KHfY*>#HoJZJF9@xUZ_ODn>e)D~AZ0r2LvW%VjXdH}PipCf>~3mCsI+7{5@( zH*>na=DD&3-JsHtT1xBvDG~ILDnNRXa|3F+uk*2TGVqo+U~0wsfv+)#56?EIm)l4)3t(WjG$XpB+`RSlLWo2 z;#)eyOPFR0>iAtBOTO?Mv0ozmwyFT<>diEuj{8xJR*qIqS3J`wLBCU>NVhUg5Hw50 zBE7&gL(qRzaw})}OQwZ_RywJV!s6?`p1SP&2)~80wsyLDFbxxQunI;xnQ5G$^Hns` zwMOW6lp8YO%N2{ zzmWD}n(@DAGSWFr3k6-Oa*?L;ygvT!tNL15-$cr}VS?tXV5G;G#tHhFibh(%G)2(= zR3g$Uxq3J91huOyqz#zb>$bbA^m2$Mh-`%J6@kR;ST!prCs>$u_js!s_s94OK z%Xt}su2#uNe_>iEXpYKl=PY-RsgLq&?`#-U-+f)fc%QU)+>RV2)IiRuong=LHXMA7b%29&OQ=v##Gffb5n~Ftx zf@y}J_&dC_Gu(1cA8(y!g+lx0ZrZ4T#Nlq!f(NTl<*@|Xg8;8G}8n@ z<5euul}s}PO;yQAk25V4^s>tBhPT?7`UJYK(|$p(KS=lqyq{shPgTL)@pZv8PEd=A zMp~b1rU=?bB_a(fuU|EJf<~z+qH(r$B6OS zD)KF-tB`4uprGP0KlLrUBU_M@D(x+2_+LCviJ;btdbhlT-B;(set_`p$`OV)hnPkQ z+Es-j4f53cksxSpp^t@q$PEo-~ zCo_!`G)YAxUBatM5j0aJA}!?HJV7_BETrBQ^}P1x?yJHxIiwLxLj;Xeem(G-ljn^Q z^ook?f%lS_CJE|uNk3|-!Vh3STlno&8qU>|X^EgiQ~}b-OaofDA4P(4^u))7X_TNl zR4CG4nI;H&NyYYbhTmhFA*l7TK8hUSS7X0W_-j-y&Xvvk>C@7EosE^Xm($gibHfD1 z>o=s+n8pcOq@t1fRML-QilF%3k90EAJVBFGRxf9GHdA{m_f?g!?<@QOFFjX?@FSGp z+xVWrG)B-=6^XQvX_BD6Djw-FKE`Z8H>otFzcMWm^olA#8s@E670}xKDDd7~Z@e;O z8YSp+6^hjBiheW`1g)!Lk-o_^L(q3sa&M=~>1}ru3bIJ$VqP}S=@a6a)bpx7hD_lHIP|{c2|r9_;avWlWpCrY#@4DB z>156g5ftyzMc}&w=f(({p(2syb8eEL78Q?l9Oq^W8n4ojE@4_CD4y*j-OV)MP4_kL zQ;tZd>lD){L9eLLNc_#qG(pfZ`Fi)(2;YzW4B?@qU(@R?6ts@YMcRg`PY3rE zMJQ`Or)xaZ7(u^K!AO@foh|4p6^(Qo(m9H~7^psJ}`^8o{|4g5pPMNIP(Dj-dUO zH44uyIJZzxJa0p~gmW#O-1jL{MI+7UTpvL#DiLWwHGM=ug5t-iNcVB&FhPG;#Yk^3 z9VRILh8~FT>RdTa&=)EaY1O~8Sg1)7qk%lo%5_GakM7oq|s-QV43uzJ4Y(afgG15*hJ#W6CcwYWK zp6f6z5p<-AM4HdkyR-XFPFL|r&F6D~po>)+()GMoodgX~1xO>R>s3Vwif3Sh@pzd| z7IeD`MVi4hLC_)!t(vs8>fuHuK{JyNDAg8r@2hC0JN3iWPe3hKjtw(tYk z&l7$(fm#f}T~uNPTMSRm~Rkp^8RY<{!O3NrKi^iAY;AO%*gkWg(5@%Gv*m79(B5 zG+)rM%5OMcO>yNCL6cM@(ydIrySeY=Q58SjS?&r`Jm(zYR2jp)UD-TWCo$fx3Whtw zgX-uVh!WI!OCS3%;m7d!$--};LPy{$nrVWdJyq-oXF0pCo@)`X*Sak zL3^rPr1ttcH$u=c$~p!gWu`HLey)PYIKxwz&K9(U{RH9rHqdh=34gUp9OEpP%Ey?h z3dT59_84#1WFDU_#$Qs!xVAM+^99XOelhr626HC`^}eHb*b?TxlSN$3Tlh^?e2mi- z&RGG14pV7Jr!(y&D4wAq{gG*up!=2M1N`id>1074s!*h!clBx$1oc+2NP`0Oey$NT zN+lz$$GI7T&Q`fd*Klr*pq-R;EPkDja|;EXu7Z&&rj~H`J^V>UkHs&Ga%KE|Jr;jo zkM%BB!cLGXKqq^wcN^b^dgWoFg6*C@-U#7G@%UjXbR6ClALs2_%1)dZ*-k}{!*9@V zouz_)sN#|4aBhmAOH~?Ddn3KJOhLm`0n*7#^90?Z9OIp?!#r=1peZVJJnjtV+EwCs zr-~cz?Xoo1bNTjg-^mv$8LI^`4H0yh%0*iJKJS&F3CcPFzX`~>F@m;I!4sV2@|n(7 z@e`aXW&-}EXrfn=B*w?8M68y|G*wV~&Ax4B%}}GhU1pu2O1|x9eM|NJZjiN$+VtIC>(1?CzMoOb`jxuAHpy1~rTT1L zKkG^L$GW=KgWF5i&9S{zF2Qbj5a!irh2_?(S7D1rmv`xZ zzO>`utA!sIzk0R16!AqZ%Rg6X8*5o7s#6;~SDnEFJZOMXU{T9es(wmsYrN`~@`jMOY9FK~Y^`4F>H{2*`M(BKzyZ(0)%vae_S9ly zjt=V7RzLeZ9sI6JFc_kPy~=M}J$tYY_N(3)l+rN^b+_8Q@0!(X`{MmS1X_RD-s0XQtF`N#_4m`) z-?u*QYaI<=ceX`X8^Z0*w&vCsP^Sw@HoQaf1I+7U3$o6J42lNB9g>yc+tt?G<{AS1 zy4spqpF;wM)+?}=WFHiftcJSXP-a0CNjNMdX#klhwu*z{aW_o70|DL9Jr3`a{0vJ; z01lI!f)bK3(Bv(Y-Y`tdaui#|_u;pt(PNq&GFlKD`o2TCl2ko1G`B+XzAimm!IIMV|YpMbq5y62%C$lCVyie1ruD+a+mJ%;F}OtX6L`OkvH-f0On^9&aM(f;0Qo4k zvQbdAw{dJ?z0o}ipOS2VRFcJTgJcT$^g)S&UL8PKL5 zMq^l`TjWJKhVBEy4es*vL1dQsSD>xe4ye09O~)|od@917cdP& z>s9!102WVye2Nx8l_-qfg`QCug~BY1Y~>>%Jqj}(!!3gQ!EYeKj?ix)Li-q4G!S6{ zWMXLD1WySjK;!o?iiF|sVblm#QuGjhrzjV!gE0CULIz>I0OyFGRI)_P=r_E>!Ao!AeW+6P*}A}LRO@9pJrU_)C^HGiE`s)xF!~Z=Nk+gAWHy0I6#0SoWQuYGXAtutMkVkqMOp9%MSG#_RE*|Ahp8CNhAAY&VFO85xIoeXDow+kE!z>gOv3{# zgpV-9chOBG%is#hJgEE;$~fpw(iJ{IvAH_HwvRC55nLnpN2oR(r_Yg%g7Z#FqgG`cO zc!Xjr+YTCjf{FLw{ZG){0ZU1e;V{V}C?Sc5CNprTy)8t~z@f#kd?Hy|9vR=PFJoQ+TMlkf|N z|IEfY3ZZ7akr_eqBYZ*f1!Rx}!W|TwcPH@s9EU!IcR$ClS}T~Z!@U^d$wm>$5vV%{ zWdlT!EP{n3Qz4V&9e6|%0s&uOeyx@;_zQZJT0$Z!o_icd8`oY!(h!==MX3tINP56> zlBST2Vso~Dmvb>=6a;;V?m!qx(hrhIBH;u{x0Uno|Dn)=q&>vw=v$IukVDc1N+qB) zfe;j1rDiZ80c$>iHRPUyKS?sdJ|E>rXh-rnOePrx>q)vo9*Hkh_zLqa!4Uct=AVG6 z7~(51g=8LFB3TID3s9n*72}OUyR*F*LFN!_|*D{Q{LBukQlHm)IpCE%|72F|t0lo?)65b{01_>l> zU@yrVP(;!h>MlpQ3sEEoVIj#D$Rt?_k4UCNzzUT9@IFaPSc+n++7OPc!1X?Z5^}FV zla(l$FpOj^EMJLB8wbZJdKX@iw1DP-iIxC}0ZhCL-(ZNZl2asKfkzU`N62RE6Bs?YQ3;u^t zx0VE4y4#|hG zjif(ZJdDd~bk$gvYZKO5c*>~Nt(8%$HUu8A1=?&^Vb~Eonp?2o2&SEdbdsZRo#bcm zI*J0&_9)i+_=-{M;}opb_!Q_#5(U#qI>S1W`fv)x zR`D{t$hL*lxOvH_)#eARHU79!>&!r-7M@7_hP4jCtluzgGi)aL2F{Vp1CL`U(;$#! z2n;%g%W9)bty+hrDjd`M6=9TW1>26{epR~!`N!~RUV-OvOv{JXBnM#x$$D5qG7t6~ z$6A9f8q0c?jJ398>qG2s)QSYJ6S%DA(D4KwM%9Zj{sfkM0e~UC#t)JF2KPxeLyh0D z*6a&Lt$}N>R7t%FZiFt2|O=A#7UgsKFm0Y zwT_)PYVG*H^* zR+B?Ut!Zx=%ks{HrMXz^9vq(^`4+m6d=8UHCcrnR@esS5Gise*g|$v( z=|k*n)an5DPvar_L!CcxXB_9C*B`huk6}87_&&9clXQi1BrU+>3{FtvECijw7eU#x@ctQms$M)}6kD|t zi&Z$F53-L@>`&Ns28*S`Rm`)l1JAQ4UqWk=i7+p8@Z4xL>cJ<2f9E7sjE$*mJh>u;!fYb=q8Rg!ENqM-kRqB@&!-qoS3n;x|07)~LgJN_20jU>g%l?2%7jVlioi>WOmSVAm zyNqHhIvK^zL*PX$b`OSL#PpT0faG&XCs_v9N!|jlODJzZ+e^4*Wpt^J7h|a=8AhpY zU5rv?Ps7qnxMf%10F6Haw@J2u^D@eE=tA-ZOd@$5zPXIG>@~~KFOTyJvDS&5My((8 z_SeXTqRY0XHjiBJy@Fe`8+u;Bysa>uWEHFjxdL;qZ1aj-);SimlQ~ID8G)`!C!l_XgCsjo|NV94DCxPf13B{|%H#=tI&1X57H-uc}M!`T|Sc*=Cg5 z(bg#C^*iL;z=yH~UeWl=(D*NuLok43E6gEDgl!}<;NoAntUf37Gi(mlTDVm&OYc}1 z1m47DHHM)#@t_G1!8NXOrh{Vftb4xQ((A0!fy`pxan1_BUf)t3JhI6@D~|jcRHX!;_EO zSnR(_kbfJCGzZT+cs#X!gOEE|yTWfU5*42mOVGxPragDC+VO0o+Otov+Lnz*wIfZ8 zYA3+!E*@n%bi9khH^4ZOi2x+S;SfnDxK9!YHSS@lq6)^#XyC_Ks@Dd+FmI#O6PR=l zOWlOk_i*?%I8G7^Pf3P@|9zCVp$|!Wm~kIV)%?|1)voDS>dtz-Du1I?88~&Hj?r^v z5gyZXPiR8=pC?42TF1kjBCOI6wvn`fi$(Zkt#s5V=K2VWEnKIIRWyo~J_2<7Cud%l4uJO1VD3QVWxeQr&78r6xe&3tZJ!82SQ-H-!Z#HrD~j zc!9fJ_5j>K#q%Gpmq>3y+m~4Ez<#6H$78Tq6EKP$aT&!jV984?_B|Y+;fvum3fy{$ zd*k~bJ}m}7m;caj1CvO6;hX=k+OvH|wezE}+KClLwU!NxYWLv&e^?FQ#a`j?Ea*w{ z6HF)h9@dczfm0;I;onzSs;w^7W+avxzuYKQy0%fO&5AxAfwo%vR?PNjWGlaK#TE}d zs1@ft8sjy$hZUth1d?ooK~|48HS%8?Yg#oN3sq2hyBtQLo3PF55s2pjS84bK@U)?v zh1Mh&V1$mAkQ{?OHZ0X(k5TH`Ff6qt(I{0_Z`Mli^1xDyp`!;5{|d&D;IoV5BRE9T zAMTShhZ?0k+SGLJHcAZ~ilurjHA>CZtE#aZCYSPPYP0NyHKp*-{)XeFFz+NhCD{r7 zrBT*GACe_7qcpB-+%BWouEALB&SIn3G^cThW8hS2T-RuLMZ*K2aT$-sHt$^!RR$|R zggF@EZIEpw2jOBFtQGg%sO5SeYb{)4)N1+cKl1MsF%KZm`Iy{VWqHutl(rq6_DZ=rVMvhEW3@HBP@? z%|69yADl<9{a6_6V~@1fPv7Qa4=QD=@Mn5KP5WLezNLL%+a7EUNYANl|J&QzJv}4P zKDx5CFuhJ^`);fCeENkh_UKZ0P1i2W9%AhP)57d=)+6cn!tCwJ;G0(CKK2p#xy_P3 z_Ih}eX-6OXc59FH4Osv9>^==&W0b>a1){R-?PV_>z2`9a1H038Yo4yYR3opsk*|y= zPG0(=5A5X~_<~LP#C{Z?wL@pvN80yKGqz@T`tcd|b5^`5vFCHn`wW$6kaHP z__@7-t=gpYZ$GzJ_3(T#&SL2`AD=o^U%=kE_LlZHM^Sp!1L@D^+B=uROT%_w*@N(8 zZ^Bph)z-N5iVN)Tm2yT6w^)KR_jfWrv%g>XWjQ>=MJ?Y;pSi^T(z{kr^Pv+*w-`Ed zRP40qiBkhV7&mTG;DqQ8CXSD8I$~P-Cu{88BW)H7M9wW&4Tk<+p*E~qP_Dwt2lfFl z=z+Z!bbVldE!0RF89g;RaMHA?lc!B>I{br)IGe@t|0@1}jT<_AbZ{#g44od>owa0{ zp`#~jOr_w(1N*z_aS!bQZS54(&%8BF%cZYrTHfaxzLn>CdpfP(Y1yvjsFo{Q?rX6@ zq60_zXlbOSotC!^fg*>e58n7S#?8{QQp*-CyR~FPd}Yr-yft8qe6FQD6p-mp;>6$3 zhIG>Mww6I!rfQk1Wx1BsTDEA}ujRCsn_6Cw_&{_OtlvaSM=kGa8L4H4mgQPDXgQ$e zf|dtbDnNWyEaucwS4#^m-L(wTGC>Qz-%!F5EgKAhPStSR&T8wPmeP=14ae2e5~!tz zmSI}r!0N>P+ODIMT5fB3p~VNXoLD6W5=j!YwA5yAEh*Z}(ei;dKh;vAO<#!g!SvgXRWFSSh8%m-p!nBGiFZ!IIWe5xf$kIdAPuf-15>X;XxWtASeS<8Mc zd0N8skOw;Qgks98ucfV)zFH>hkx5!IAif6fV7`tP>LFii*`UP&1vRkPAst=R@>okL zh^>jNhL#{L-L(wVGG5DPT9#<}LCX#;N3>kga!<=EEma_^7S7 z7Fv2}8LR~#0AlmCtkns-v>exR35sdRBQ512(hs8=T7tFUvyRO7wZv+frzHu}h;7%B zqvb9*UPrSu#FF?zC`p)>+S+WTB}SWl%*aTXqobvorE2+Fo2gpzwRy~l{^t*h>9<>p zW%q0PUj>lpk2C*gNU-^*e&i^78U0l`={JC4%>JLh<748ZGFxEyJ};*Roj4k6N;{TrvbA8el~)h;M+U@NJi*m6o@) z4At_H7JR>@A)B;hYFVR~a1lZSkQHeu4~Y#i!ryWv%^;arA1!%0p+t)>SZT<3&G0>l zq8KepwPa|SuZ!Wcord7s4T@_o|CJc?VG8iq|FT0d;k^G34$}DH{|DP4tr5-<1@R=a zwfJeXt(H`6=4r8jqcM*3)iOX2nW|-;mepFeX*r?gA1xNJHoEL&2yKd0 zYH4YqB|^(+E%91bYQYydB^=jsS<8K}2I6C5{;?4Ap{w3N|0@B45#xuUhU7ss4Yu&# z-Y^H}@!3^Ajv_txKhz-WdxK|`ywcu|#iXyZOgk*~1bhJhb zeld*9LM=WJ+zg{IEmL&DWE~}GSpt#G@wChsSEyyP9_J0klpLfbLQ9;MBgPPz-Q3d~ zQiDD1c!M;)IS%%LG?D-ype0|McJOP5BZIUIgGh=J z3~@c-KPg}?+a9R@h40`r3g5v=JfVQ3j+WM1!nF+1@*#w_$47Caj_?!?6I>Q<>o%*` z0m<9gOORw9!$7mhlkW!L#+OFSt8?DJy;boqkqvZ1&dU<*@OS$-dcD z@4mpJd;{P2Faz`ziJ}a2>PBJ%|0@ z**DwUbJ>r;IyAq<>})^H-~}g`J?($6AIN>`W;gqv?DuEi>|;N}{v!6x4)(L`|HwY} zt{d}P&M`Q|z-(K`TWH45W%kX6b-dGN{KRmZx!J0Ycjt_sXFT3)QpbCE#!n`XH`~)M z>EpLp8r{@SC$lphZx0$jZ?SLoq+elwGWVIA-RM`@&tc!}L(ga5hr7qk4)g-{<7P21 zo6oN?7|9cxZRbt+bvd1V^GWmu`-|B(Tg{uYAHWUbW|Mg!`;*z9W%ic`G1$(9%+B(q z>=$u@*;Ag#{tX^)c9Sn-|2g|+ANeEp&Hi!j7oTN`;&+zzf9r>!59?m`hjDB+iSJ`S zj(xLLd_Vgu**BZS53q0H=4!J&Jk#*;`4_>!>p`xyI!s1W{`P2R`ZU&y}M z-hG1o6!xjH+j#x`&fqKqv#0wc`w!VSySY!XUz zGibrR+h#X*1NM8eZ}wpaus@o8vm3i1`$^n?ZT4X|V*d*s?=y?rs2ej#W?(j7H(`G_ z`)1qq7wlWOS=wy4p3D9)_RUu7FWEoKb<8H~S@X<7+yia)S0}I^#lG2DJ)iwG?3+E+ zU$JlYQk%Wg3)p|a6PsPr3$;JXl4`b5vo7KUvr*b?j9$!s05?0EEzwKZZ_e$&W;66s z_It8#wm~PdKgRIs_0PS`%NTsl31;uJV&Cj}HhY}^W`8x0H@ll#7|$q+Wk367k8?}* zFR^cQH`D8HID;H+P&ONz&HG4ZL$leyT!F_o<;G&Ob-5z@!`L^Qmc7|u#J<_C>_Fdm z{qJXBb}Coqgoo^#J<5C^%;If!`?6Ny@lhO`eaThXpUuA6kz9@aPIv9b{1&qrnQwMk zrgQtT*@o=H2|uxKHXys$Kgzz@hFqQf8|<6S$TiqEn~tC;(T>#*OB zeY5M>m;DdfH~WqK*EpLpws3;kUd&fdmK09NW^KZSuJCxX zz4#6GU$AdB76-FGjN5_Dmf}$MXC*K&yNNq9XvMw9W*>1E_TORO>?ZEYek}WDA8|MK zy}38o>>xG|c%dF&(_%Icd-MH~^;~H0eY+~QRo&UsGr`AtJAM8L&-4hJ$6Dz8i)Yhd z=UV-~&68O0`x^M;u+$d*f4^!UKZE%NubSElJSAJ>UXV+8*8%scHyPu7?;VKeitP7{ zGkAyPI|wG6D)33hM;W&Xi7*|UU%Th=tyhY%j86SpR!e<1o zZ(LJ3EX82Wz$3M0x*yTkjD3D^_y1(Sp71Lfmtqb}D~QH&u3iFv&Ug?c60R&}d&2k& z$RfN_WREp2=Ny(Fp_p){z*iXK9oJom3kB|LT=Y3CB@jv2bA$U49c5e_;t4ks_)X)| z&|&EYX@my~yp{1ZC?LE@;Ma`{NQY%3ICdl6EAUFjxe!XYP~h^$WhSjW7IApRjqWR- z$+)`kGuRIh{sZ<~K`xd9pFN)5pp=gxiV7t+#Pm>#+2K zXu|ykKFD|vBoh8j6mMl*{5mY-AdB#0fj2Rp3&n(Mrnnz{ZQ~NzVZmEgdl7dRcp2lt z5J~uRfy)>d(hf^H#1p^FzV1GxB41@3-Lm+JuWgpUfmoAG@}LmXb}C-+I4Uf0>R zgdf9xknq>C-vu0*I9sH^)o$o=Jt36vK(RAlFM#9Ml{!B9Xr?zwx_YmDQ-aR~7@BD?=>ot*)pgm(yhjPWIiMI7#t>R!CV z9i8nEejNMFg#R=9qac@Nn<8-iySf~H{BRgC2>dl;`~(7V_+5c3-P74M)7%#s#(uc) zKW9G<5^1(|0zYB=Gh`9|UEs0z^=!|fn6T&1?vq|&+yeZLARZ`i-y)s89wG@Z68I?N zoe+;W{JOwz7VB*9?e3FKWj|Q>TiG881vDE7{Q3i3?kG5p;%tuvUdh<=7x&q6*!L5D z`G>k(2*hGJS1*BQGLD91!XFC!fbqAGOZXS@CNuhxE}jL}UlAV@*%ug}hhV}7MRxDU zI{Pd{6Asy^8P^fonh2+0Vc)8*!DL?sG3= zY==m~0sp$=G9@~@8N?HQTV#L2I1JJV$B68Ej1!=MaH_z=pXuV`!0{X61X27f<2?{c z_`cZG9?x~Q1!4&Yyl`Ln{{O+rh{GR<;?4fm*=5t+)5f#!6#fSG>x1-TUL^34|M*BV z+^Z(BUq|?-*~hOs9mm-^3f%pbE{9hfgqw?v*v+^%q!CUQ*-b50Om|pzLIL4if!8v= z1CA4TDArx>ORi?s*)@e9!G3Guf5mk%Y$x{3T=jS}x&L0zYTG719VF7kFY> zUAzzq5Qje&_!{F1d)$wxrd_Ai5q^L610nPj&elcXV~j^bEaBAxcPOW;?uBH+cLn~L zab3tI+LlAf9lEz;9O4 z*}jlQ_yh5dv6XQc6d-m)?sq@1*TL^JUhn&!_O!be3AWNpS6&ODIL5U@;PT!YHD^l7!zEHzixWrnBQ9i|}vaM&BmJ#ZXMRl(?l-yNb@91b%-aen;H7SjKo7L=v7O zaG9z)dnLpZUMKJ;jPoFka9MF{;vVA(P(b)=frnSq#qpHz4C3YDa{nx2{9Ym99D#c{ zb@n5OMI7$A$^DtMpK%T0m#`ls{AND7TsO$2*@gN@)_BoZzwZWesRxHe=FepBFEjNgW0!lMKpQbQNVFMysy{H4IB8Lxs! z!kGehuc@;OA)as*d1rxfD5Mb{ByiJOI{O1CAiPlEwTzR&k%u@<;A*vXb{>Qh9x1N% zzhXQMVhLvm{2$}vkW4t>x%=~DN*!H10&)q@6W63S8DrnWdBjHre$Q8D--Tepb;MQT zNygz2O?a-ro&9w7CP+ja{-?k@8Qa9wU=jO4!f*7tE;j^f*JbfN+?&>bu5x1~@Jv-Xd`SdO91w zZ%+72aUFJyG4>N64u2qUhx$6ZoVZ4cW51s8e`Y@)a%r~J;u@lU16}S1)PO5KOqWI4`dhptF-8nsBPXpEEuHiGdvmBP&5Q{iGN*w7-#-+u%K?eJAV*CU4Ga;8| zD-?LN@qI6c#T%?w5qA=2LKhgfgJ8lj;OgEB z4)&_x#6Mq_TLtAJL}L_u_rCi>X@2r*Epqomvgzc{VM&1>y($E{z7yCy!^nVQtm@h; za4-I(F$es-5swgfB!9~JB}5XQB=D#F*(v@lLc&7?wll_73&arOUBSED^567w8$tnk z!<&l~U&b!sn;#AP3;zY5UzHL5P2Lqp5xnQ9&>cI)lO4FiJTc7t#1xx42|p6J=1INS zf5BS0LSS`kvHRAWpNy6-h8~qGGFBH)8;CMO_eJQ;fFij_q7VC z)?j&{3H-skJW%rk`Q~7)iYpBfOEI4X?ID6A?{G5Fc#1js@?fwv$Pw$=j>76CA s&8PPvD8Ov%#q?*@DySW0nneeX2pT1udD_nj_ifJ#Q%n`wcd z!&MH_Xr}g>?&FMCWk^>s4Hk5R@@?sKeZw?H(7h_6rL#&t(-alb(y0<#dUYvgCs(xp zhyAOTuEy;6z3e{P0Oe@qbai7IDd=z&f^-VgL_z1MIHU83G+5C4?1u~g5&JR1ucRXUovu2E^(;~Z^-~E*yD`lb zbg;@mI*w_%pmC}YX(CgKSAS z-(RJ*ak_djEfRE;%11hvskhU8jBAy(t<$xGX{eyTtDv^du**#21%1qZlJH|~RgAMu zy6}@!GWO-n)w3uNG*IQxNI2K-?LN)|RfcpR=LQQpR`~`vT^0}BZ;YURDgx;o&P@?? znMy$V8Pi-r!&L^-ET-jx9#w@%uQ2s+PDh}yb zrdfifsx+jzJl`Tgi&Q>RuL^oKyz9D;Do|O2oUR32IaJV@%st&3QX*^dB7Bp4)wsX3&nZ^hjt|Hnws}wQCb9p;F zm$&nBy~};&iuQ>r1FP99>h&oXbc-rP`U~g!)psA~Ipt{Y47A=P;d}nBXHhQv2C5MI3S{cn$bA-}%F)T`n!q$t(1j`lX%f>!K{u;7 zq5_wiIZu4myb{5s0o+3E6U8Y*ZH6@+vM(|AFrt7xQ4 zn5GN*sY*ur9n%6q_o|%E&aksg?Y{1#EoR?G_|Mo67XHi1H`wWFbwbZEM$qmm0_ht} zQv{u=5|GYknk(p9m4Wnorsaa3P=!cuG4*TgJ_|qP=z?cLK8HjKYEdCbz4P>#69tV` zaY%!hW(hh#r6HZfv`Ektm5(%w`}J<(KB{+>^%bXU4d;dmTBL%IZeetMD%!SJFD*o1uaM zk33z_J}MdMNTvmX#;P2o%bD6+xQ}hKDnq)LX|SNDly7&Z^674O#0Y{{=iTwWa$1il zMbH41fHZ_@uAq@B18E%7azR(9LZqKF_49KdZ@O~yz~A#sBLzLFLV7sEikT(~`k4Jx z;nzB&XOSiRAeDyIuJUVAB&embKK3mw-ACxhzPIpSSJs|*?qM1#XsilCn!+?*&}e8EFyc76`gg(Sa{wD9`47@Tm0R}Q|FwXqqp$eD{F73YXH+wL8qu7q)V8_3%XuK zBmIGCx}f1IxwkXy1k(aR|75>Z_TbJ?&G|}exUG^cs)afpQVEO;roJV zyr6a!-OstEpWTrzKs}X=X~9+X8>T?eD3yaWk*Phs8NJ}|4UQjO;J=hs`hI7*ey~lpG@BQ=fvMjs?qlAh z91%`e2GdAEvsFk0{_=}4yDUERlt4`_$r z`L(8gT|xz&tAda&Vj3?fp7oKg;L7QO;#nVQI@1C{_oy7CMO@kbs{5$CR2kCXm-VQE z1&vX@Z{R~OrZIvRs0gH4Oj88CsuGai<5A@bYE>CXU4?p`%LQ$%3X%3?>etPE%)^vp zDBkQajTCg53PHM=X`-NZ6^C>m(=0(xsWha;Op64ys(hsNuIVv*cXuCEJ7pc_biK|r zM$pMB2raJ^ZqH>1ehfYj$1%1kXp73j5*R!}P{8q|$ zINn&*(#J!±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 KnqxJ(SN}gB3+7h< diff --git a/03_nf4_dequant/nf4/ikko/mainla.cu b/03_nf4_dequant/ikko/mainla.cu similarity index 97% rename from 03_nf4_dequant/nf4/ikko/mainla.cu rename to 03_nf4_dequant/ikko/mainla.cu index 1008a4f..2614b56 100644 --- a/03_nf4_dequant/nf4/ikko/mainla.cu +++ b/03_nf4_dequant/ikko/mainla.cu @@ -176,17 +176,17 @@ __global__ void nf4_decode_kernel( int main(int argc, char** argv) { // 1.输入解析，读取二进制文件 - std::string input_file = "03_nf4_dequant/nf4/ikko/data/weight_data.bin"; - std::string output_file = "03_nf4_dequant/nf4/ikko/data/output.bin"; + std::string input_file = "03_nf4_dequant/ikko/data/weight_data.bin"; + std::string output_file = "03_nf4_dequant/ikko/data/output.bin"; enum class OutputType { BF16, FP16 }; OutputType output_type = OutputType::BF16; if (argc >= 2) { if (std::strcmp(argv[1], "bf16") == 0) { output_type = OutputType::BF16; - output_file = "03_nf4_dequant/nf4/ikko/data/output_bf16.bin"; + output_file = "03_nf4_dequant/ikko/data/output_bf16.bin"; } else if (std::strcmp(argv[1], "fp16") == 0) { output_type = OutputType::FP16; - output_file = "03_nf4_dequant/nf4/ikko/data/output_fp16.bin"; + output_file = "03_nf4_dequant/ikko/data/output_fp16.bin"; } else { std::cerr << "Usage: " << argv[0] << " [bf16|fp16] [output_file]" << std::endl; return 1; @@ -202,7 +202,7 @@ int main(int argc, char** argv) { std::cerr << "CWD: " << cwd << std::endl; } std::cerr << "Error: Cannot open input file: " << input_file << std::endl; - std::string fallback_file = "03_nf4_dequant/nf4/ikko/data/weight_data.bin"; + std::string fallback_file = "03_nf4_dequant/ikko/data/weight_data.bin"; infile.open(fallback_file, std::ios::binary); if (!infile) { std::cerr << "Error: Cannot open fallback input file: " << fallback_file << std::endl; diff --git a/03_nf4_dequant/nf4/ikko/mainla.maca b/03_nf4_dequant/ikko/mainla.maca similarity index 97% rename from 03_nf4_dequant/nf4/ikko/mainla.maca rename to 03_nf4_dequant/ikko/mainla.maca index 32e08c7..6acfc63 100644 --- a/03_nf4_dequant/nf4/ikko/mainla.maca +++ b/03_nf4_dequant/ikko/mainla.maca @@ -76,8 +76,8 @@ __global__ void nf4_decode_kernel_fp16( } int main(int argc, char** argv) { - std::string input_file = "data/weight_data.bin"; - std::string output_file = "data/output_fp16_maca.bin"; + std::string input_file = "03_nf4_dequant/ikko/data/weight_data.bin"; + std::string output_file = "03_nf4_dequant/ikko/output_fp16_maca.bin"; if (argc >= 2) { if (std::strcmp(argv[1], "fp16") != 0) { @@ -96,7 +96,7 @@ int main(int argc, char** argv) { std::cerr << "CWD: " << cwd << std::endl; } std::cerr << "Error: Cannot open input file: " << input_file << std::endl; - std::string fallback_file = "data/weight_data.bin"; + std::string fallback_file = "03_nf4_dequant/ikko/data/weight_data.bin"; infile.open(fallback_file, std::ios::binary); if (!infile) { std::cerr << "Error: Cannot open fallback input file: " << fallback_file << std::endl; diff --git a/03_nf4_dequant/nf4/ikko/mainla.mu b/03_nf4_dequant/ikko/mainla.mu similarity index 97% rename from 03_nf4_dequant/nf4/ikko/mainla.mu rename to 03_nf4_dequant/ikko/mainla.mu index bb7b39f..c1e7678 100644 --- a/03_nf4_dequant/nf4/ikko/mainla.mu +++ b/03_nf4_dequant/ikko/mainla.mu @@ -91,8 +91,8 @@ __global__ void nf4_decode_kernel_fp16( } int main(int argc, char** argv) { - std::string input_file = "data/weight_data.bin"; - std::string output_file = "data/output_fp16_mu.bin"; + std::string input_file = "03_nf4_dequant/ikko/data/weight_data.bin"; + std::string output_file = "03_nf4_dequant/ikko/output_fp16_mu.bin"; if (argc >= 2) { if (std::strcmp(argv[1], "fp16") != 0) { @@ -111,7 +111,7 @@ int main(int argc, char** argv) { std::cerr << "CWD: " << cwd << std::endl; } std::cerr << "Error: Cannot open input file: " << input_file << std::endl; - std::string fallback_file = "data/weight_data.bin"; + std::string fallback_file = "03_nf4_dequant/ikko/data/weight_data.bin"; infile.open(fallback_file, std::ios::binary); if (!infile) { std::cerr << "Error: Cannot open fallback input file: " << fallback_file << std::endl; diff --git a/03_nf4_dequant/nf4/ikko/ncu_report.txt b/03_nf4_dequant/ikko/ncu_report.txt similarity index 100% rename from 03_nf4_dequant/nf4/ikko/ncu_report.txt rename to 03_nf4_dequant/ikko/ncu_report.txt diff --git a/03_nf4_dequant/nf4/ikko/readme.md b/03_nf4_dequant/ikko/readme.md similarity index 98% rename from 03_nf4_dequant/nf4/ikko/readme.md rename to 03_nf4_dequant/ikko/readme.md index fa489ca..6c4677d 100644 --- a/03_nf4_dequant/nf4/ikko/readme.md +++ b/03_nf4_dequant/ikko/readme.md @@ -1,6 +1,29 @@ ## 测试 +~/Learning-CUDA目录下 + +```bash +# 默认 bf16 make nf4 + +# 显式指定 dtype +make nf4 DTYPE=fp16 +make nf4 DTYPE=bf16 + +# 简写（等价于上面的 DTYPE） +make nf4 fp16 +make nf4 bf16 + +# 指定 GPU make nf4 CUDA_DEVICE=7 +make nf4 fp16 CUDA_DEVICE=7 + +# 查看用法 +make help +``` + +说明： +- `make nf4 fp16` 中的 `fp16` 是 Make 目标简写，Makefile 已兼容并自动映射为 `DTYPE=fp16`。 +- 运行阶段会传参给 `mainla`，输出路径随 dtype 自动切换到 `data/output_fp16.bin` 或默认 bf16 输出文件。 ## NF4反量化 权重 = NF4表值 × (一级scale × 二级scale) + offset scale = code2[ absmax_q[block] ] × absmax2[group] diff --git a/03_nf4_dequant/nf4/ikko/testbit.py b/03_nf4_dequant/ikko/testbit.py similarity index 100% rename from 03_nf4_dequant/nf4/ikko/testbit.py rename to 03_nf4_dequant/ikko/testbit.py diff --git a/03_nf4_dequant/nf4/ikko/verify_mae.py b/03_nf4_dequant/ikko/verify_mae.py similarity index 96% rename from 03_nf4_dequant/nf4/ikko/verify_mae.py rename to 03_nf4_dequant/ikko/verify_mae.py index 23da03f..4d87ebd 100644 --- a/03_nf4_dequant/nf4/ikko/verify_mae.py +++ b/03_nf4_dequant/ikko/verify_mae.py @@ -3,7 +3,7 @@ import os import struct -def check_mae(output_dir="03_nf4_dequant/nf4/ikko/data", cuda_output_file="03_nf4_dequant/nf4/ikko/data/output.bin"): +def check_mae(output_dir="03_nf4_dequant/ikko/data", cuda_output_file="03_nf4_dequant/ikko/data/output.bin"): truth_file = os.path.join(output_dir, "ground_truth.bin") input_file = os.path.join(output_dir, "weight_data.bin") diff --git a/Makefile b/Makefile index 5228d6f..2c6aa9d 100644 --- a/Makefile +++ b/Makefile @@ -1,13 +1,42 @@ CUDA_DEVICE ?= 0 PYTHON ?= python +DTYPE ?= bf16 -NF4_DIR := 03_nf4_dequant/nf4/ikko +# Usage: +# make nf4 # default bf16 +# make nf4 DTYPE=fp16 # explicit dtype +# make nf4 fp16 # shorthand dtype selector + +NF4_DIR := 03_nf4_dequant/ikko NF4_CU := $(NF4_DIR)/mainla.cu NF4_BIN := $(NF4_DIR)/mainla NF4_VERIFY := $(NF4_DIR)/verify_mae.py + +ifneq ($(filter fp16,$(MAKECMDGOALS)),) +DTYPE := fp16 +endif +ifneq ($(filter bf16,$(MAKECMDGOALS)),) +DTYPE := bf16 +endif + +ifneq ($(filter $(DTYPE),bf16 fp16),$(DTYPE)) +$(error Invalid DTYPE='$(DTYPE)'. Use bf16 or fp16) +endif + +ifeq ($(DTYPE),fp16) +NF4_OUTPUT := $(NF4_DIR)/data/output_fp16.bin +else NF4_OUTPUT := $(NF4_DIR)/data/output.bin +endif + +.PHONY: nf4 bf16 fp16 help -.PHONY: nf4 +help: + @echo "Usage:" + @echo " make nf4" + @echo " make nf4 DTYPE=fp16" + @echo " make nf4 fp16" + @echo " make nf4 bf16" # NF4 one-command pipeline: compile + run + verify nf4: @@ -15,7 +44,10 @@ nf4: @mkdir -p .tmp TMPDIR=$(CURDIR)/.tmp /usr/local/cuda/bin/nvcc -O3 -std=c++17 -arch=sm_80 $(NF4_CU) -o $(NF4_BIN) @echo "=== [NF4] Running $(NF4_BIN) ===" - @echo "=== CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) ===" - CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) ./$(NF4_BIN) bf16 $(NF4_OUTPUT) + @echo "=== CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE), DTYPE=$(DTYPE) ===" + CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) ./$(NF4_BIN) $(DTYPE) $(NF4_OUTPUT) @echo "=== [NF4] Verifying MAE ===" CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) $(PYTHON) $(NF4_VERIFY) + +bf16 fp16: + @: From d3f3306728bc7b414f636c78570c621a0239d13d Mon Sep 17 00:00:00 2001 From: ikko-debug <862049654@qq.com> Date: Sun, 15 Mar 2026 13:27:01 +0800 Subject: [PATCH 3/3] update makefile --- Makefile | 99 +++++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 80 insertions(+), 19 deletions(-) diff --git a/Makefile b/Makefile index 2c6aa9d..9b99db5 100644 --- a/Makefile +++ b/Makefile @@ -1,15 +1,17 @@ CUDA_DEVICE ?= 0 PYTHON ?= python DTYPE ?= bf16 +PLATFORM ?= nvidia # Usage: -# make nf4 # default bf16 -# make nf4 DTYPE=fp16 # explicit dtype -# make nf4 fp16 # shorthand dtype selector +# make nf4 PLATFORM=nvidia +# make nf4 PLATFORM=nvidia DTYPE=fp16 +# make nf4 PLATFORM=metax +# make nf4 PLATFORM=moore +# make nf4 PLATFORM=metax bf16 +# make nf4 PLATFORM=moore fp16 NF4_DIR := 03_nf4_dequant/ikko -NF4_CU := $(NF4_DIR)/mainla.cu -NF4_BIN := $(NF4_DIR)/mainla NF4_VERIFY := $(NF4_DIR)/verify_mae.py ifneq ($(filter fp16,$(MAKECMDGOALS)),) @@ -23,31 +25,90 @@ ifneq ($(filter $(DTYPE),bf16 fp16),$(DTYPE)) $(error Invalid DTYPE='$(DTYPE)'. Use bf16 or fp16) endif +# ========================================================= +# Platform selection +# ========================================================= +ifeq ($(PLATFORM),nvidia) + CC := /usr/local/cuda/bin/nvcc + SRC_SUFFIX := cu + CFLAGS := -O3 -std=c++17 -arch=sm_80 + EXTRA_LIBS := + NF4_BIN := $(NF4_DIR)/mainla + RUN_ENV := CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) + +else ifeq ($(PLATFORM),metax) + CC := mxcc + SRC_SUFFIX := maca + CFLAGS := -O3 -std=c++17 + EXTRA_LIBS := + NF4_BIN := $(NF4_DIR)/mainla_maca + RUN_ENV := + +else ifeq ($(PLATFORM),moore) + CC := mcc + SRC_SUFFIX := mu + CFLAGS := -O3 -std=c++11 + EXTRA_LIBS := -I/usr/local/musa/include \ + -L/usr/lib/gcc/x86_64-linux-gnu/11/ \ + -L/usr/local/musa/lib \ + -lmusart + NF4_BIN := $(NF4_DIR)/mainla_mu + RUN_ENV := + +else ifeq ($(PLATFORM),iluvatar) + CC := clang++ + SRC_SUFFIX := cu + CFLAGS := -O3 -std=c++17 + EXTRA_LIBS := -lcudart -I/usr/local/corex/include -L/usr/local/corex/lib64 -fPIC + NF4_BIN := $(NF4_DIR)/mainla_iluvatar + RUN_ENV := CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) + +else + $(error Unsupported PLATFORM '$(PLATFORM)' (expected: nvidia, metax, moore, iluvatar)) +endif + +NF4_SRC := $(NF4_DIR)/mainla.$(SRC_SUFFIX) + ifeq ($(DTYPE),fp16) NF4_OUTPUT := $(NF4_DIR)/data/output_fp16.bin else NF4_OUTPUT := $(NF4_DIR)/data/output.bin endif -.PHONY: nf4 bf16 fp16 help +.PHONY: nf4 run verify clean help bf16 fp16 help: @echo "Usage:" - @echo " make nf4" - @echo " make nf4 DTYPE=fp16" - @echo " make nf4 fp16" - @echo " make nf4 bf16" - -# NF4 one-command pipeline: compile + run + verify -nf4: - @echo "=== [NF4] Compiling $(NF4_CU) ===" + @echo " make nf4 PLATFORM=nvidia" + @echo " make nf4 PLATFORM=nvidia DTYPE=fp16" + @echo " make nf4 PLATFORM=metax" + @echo " make nf4 PLATFORM=moore" + @echo " make run PLATFORM=metax" + @echo " make verify" + +nf4: $(NF4_BIN) + @echo "=== [NF4] Running $(NF4_BIN) ===" + @echo "=== PLATFORM=$(PLATFORM), DTYPE=$(DTYPE) ===" + $(RUN_ENV) ./$(NF4_BIN) $(DTYPE) $(NF4_OUTPUT) + @echo "=== [NF4] Verifying MAE ===" + $(PYTHON) $(NF4_VERIFY) + +$(NF4_BIN): $(NF4_SRC) + @echo "=== [NF4] Compiling $(NF4_SRC) with $(CC) ===" @mkdir -p .tmp - TMPDIR=$(CURDIR)/.tmp /usr/local/cuda/bin/nvcc -O3 -std=c++17 -arch=sm_80 $(NF4_CU) -o $(NF4_BIN) + TMPDIR=$(CURDIR)/.tmp $(CC) $(CFLAGS) $(NF4_SRC) -o $(NF4_BIN) $(EXTRA_LIBS) + +run: @echo "=== [NF4] Running $(NF4_BIN) ===" - @echo "=== CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE), DTYPE=$(DTYPE) ===" - CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) ./$(NF4_BIN) $(DTYPE) $(NF4_OUTPUT) + @echo "=== PLATFORM=$(PLATFORM), DTYPE=$(DTYPE) ===" + $(RUN_ENV) ./$(NF4_BIN) $(DTYPE) $(NF4_OUTPUT) + +verify: @echo "=== [NF4] Verifying MAE ===" - CUDA_VISIBLE_DEVICES=$(CUDA_DEVICE) $(PYTHON) $(NF4_VERIFY) + $(PYTHON) $(NF4_VERIFY) + +clean: + rm -f $(NF4_DIR)/mainla $(NF4_DIR)/mainla_maca $(NF4_DIR)/mainla_mu $(NF4_DIR)/mainla_iluvatar bf16 fp16: - @: + @: \ No newline at end of file