quack-kernels 0.1.0__py3-none-any.whl

quack/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1.0"
+
+from quack.rmsnorm import rmsnorm
+from quack.softmax import softmax
+from quack.cross_entropy import cross_entropy

quack/cross_entropy.py

@@ -0,0 +1,221 @@
+import math
+import torch
+import operator
+from typing import Callable, Union
+
+import cuda.bindings.driver as cuda
+
+import cutlass
+import cutlass.cute as cute
+from cutlass.cute.runtime import from_dlpack
+
+import quack.utils as utils
+
+
+@cute.kernel
+def cross_entropy_kernel(
+    mX: cute.Tensor,  # (M, N)
+    mTarget: cute.Tensor, # (M,)
+    mLoss: cute.Tensor, # (M,)
+    tv_layout: cute.Layout,
+    tiler_mn: cute.Shape,
+    cluster_n: cutlass.Constexpr = 1,
+):
+    tidx, _, _ = cute.arch.thread_idx()
+    bidx, cluster_y, _ = cute.arch.block_idx()
+    gdim, _, _ = cute.arch.grid_dim()
+
+    shape: cute.Shape = mX.shape
+    idX = cute.make_identity_tensor(mX.shape)
+    gX, cX = [cute.zipped_divide(mT, tiler_mn) for mT in (mX, idX)]
+    blkX, blkCrd = [gT[(None, None), bidx if cluster_n == 1 else (bidx, cluster_y)] for gT in (gX, cX)]
+
+    # declare the atoms which will be used later for memory copy
+    copy_atom_load_X = cute.make_copy_atom(cute.nvgpu.CopyUniversalOp(), gX.element_type, num_bits_per_copy=128)
+    copy_atom_load_X_async = cute.make_copy_atom(cute.nvgpu.cpasync.CopyG2SOp(), gX.element_type, num_bits_per_copy=128)
+    copy_atom_scalar = cute.make_copy_atom(cute.nvgpu.CopyUniversalOp(), gX.element_type, num_bits_per_copy=gX.element_type.width)
+
+    thr_copy_X = cute.make_tiled_copy(copy_atom_load_X, tv_layout, tiler_mn).get_slice(tidx)
+    thr_copy_X_async = cute.make_tiled_copy(copy_atom_load_X_async, tv_layout, tiler_mn).get_slice(tidx)
+
+    smem = cutlass.utils.SmemAllocator()
+
+    # Don't use blkX.layout here, because the stride is N, not N_rounded
+    sX = smem.allocate_tensor(gX.element_type, cute.make_ordered_layout(blkX.shape, order=(1, 0)), byte_alignment=16)
+    num_warps = cute.size(tv_layout, mode=[0]) // cute.arch.WARP_SIZE
+    warps_per_row = utils.max_constexpr(tv_layout.shape[0][0] // cute.arch.WARP_SIZE, 1)
+
+    reduction_buffer_layout = cute.make_ordered_layout(
+        # 2 stages: 1 for max, 1 for sum
+        (num_warps // warps_per_row, warps_per_row if cluster_n == 1 else (warps_per_row, cluster_n), 2),
+        order=(1, 0, 2)
+    )
+    reduction_buffer = smem.allocate_tensor(cutlass.Float32, reduction_buffer_layout, byte_alignment=4)
+    if cutlass.const_expr(cluster_n > 1):
+        # 1 mbar for max reduction, 1 mbar for sum reduction
+        mbar_ptr = smem.allocate_array(cutlass.Int64, num_elems=2)
+    else:
+        mbar_ptr = None
+
+    #### Thread View
+    tXgX = thr_copy_X_async.partition_S(blkX)
+    tXsX = thr_copy_X_async.partition_S(sX)
+
+    tXcX = thr_copy_X.partition_S(blkCrd)[(0, None), None, None]
+
+    # allocate fragments for gmem->rmem
+    tXrX = cute.make_fragment_like(tXgX)  # only logits fragment needed
+
+    if cluster_n > 1:
+        if tidx < 2:
+            cute.arch.mbarrier_init_arrive_cnt(mbar_ptr + tidx, 1)
+        cute.arch.mbarrier_init_fence()
+        if tidx < 2:
+            cute.arch.mbarrier_init_tx_bytes(mbar_ptr + tidx, num_warps * cluster_n * cutlass.Float32.width // 8)
+        # Cluster arrive after barrier init
+        cute.arch.cluster_arrive_relaxed()
+
+    row = tXcX[0][0]
+    target = cute.Int32.zero
+    if row < shape[0] and tXcX[0][1] == 0:
+        target = cute.Int32(mTarget[row])
+
+    tXpX = cute.make_fragment_like(tXgX[(0, None), None, None], cutlass.Boolean)
+    for i in range(cute.size(tXpX)):
+        tXpX[i] = cute.elem_less(tXcX[i][1], shape[1])
+    if row < shape[0]:
+        cute.copy(copy_atom_load_X_async, tXgX, tXsX, pred=tXpX)
+    cute.arch.cp_async_commit_group()
+    cute.arch.cp_async_wait_group(0)
+    cute.autovec_copy(tXsX, tXrX)
+    x = tXrX.load().to(cute.Float32)
+
+    target_logit = cute.Float32.zero
+    if row < shape[0] and tXcX[0][1] == 0:
+        target_logit = cute.Float32(mX[row, target])
+
+    max_x = utils.warp_reduce(
+        x.reduce(cute.ReductionOp.MAX, init_val=float('-inf'), reduction_profile=0),
+        cute.arch.fmax,
+        width=utils.min_constexpr(tv_layout.shape[0][0], cute.arch.WARP_SIZE),
+    )
+    if cutlass.const_expr(cluster_n > 1):
+        cute.arch.cluster_wait()
+    if cutlass.const_expr(warps_per_row > 1 or cluster_n > 1):
+        max_mbar_ptr = mbar_ptr + 0 if cluster_n > 1 else None
+        max_x = utils.block_or_cluster_reduce(
+            max_x, cute.arch.fmax, reduction_buffer[None, None, 0], max_mbar_ptr, init_val=-cutlass.Float32.inf
+        )
+    log2_e = math.log2(math.e)
+    # exp_x = cute.math.exp2((x - max_x) * log2_e, fastmath=True)
+    exp_x = utils.exp2f((x - max_x) * log2_e)  # a bit faster, idk why
+    denom = utils.warp_reduce(
+        exp_x.reduce(cute.ReductionOp.ADD, init_val=0.0, reduction_profile=0),
+        operator.add,
+        width=utils.min_constexpr(tv_layout.shape[0][0], cute.arch.WARP_SIZE),
+    )
+    if cutlass.const_expr(warps_per_row > 1 or cluster_n > 1):
+        sum_mbar_ptr = mbar_ptr + 1 if cluster_n > 1 else None
+        denom = utils.block_or_cluster_reduce(
+            denom, operator.add, reduction_buffer[None, None, 1], sum_mbar_ptr, init_val=0.0
+        )
+
+    if tXcX[0][1] == 0 and row < shape[0]:
+        ln_2 = math.log(2.0)
+        loss_val = -target_logit + max_x + utils.log2f(denom) * ln_2
+        if cutlass.const_expr(cluster_n == 1):
+            mLoss[row] = loss_val.to(mLoss.element_type)
+        else:
+            if cute.arch.block_idx_in_cluster() == 0:
+                mLoss[row] = loss_val.to(mLoss.element_type)
+
+
+@cute.jit
+def cross_entropy_interface(
+    mX: cute.Tensor,
+    mTarget: cute.Tensor,
+    mLoss: cute.Tensor,
+    stream: cuda.CUstream,
+    N: cutlass.Constexpr,
+    copy_bits: cutlass.Constexpr = 128
+):
+    vecsize = copy_bits // mX.element_type.width
+    assert N % vecsize == 0, f"Input N {N} is not divisible by vector size {vecsize}"
+    num_threads = 128 if N <= 16384 else 256
+
+    num_warps = num_threads // cute.arch.WARP_SIZE
+    assert num_threads % cute.arch.WARP_SIZE == 0
+    threads_per_row = 8 if N <= 64 else (16 if N <= 128 else (32 if N <= 3072 else (64 if N <= 6144 else (128 if N <= 16384 else 256))))
+
+    if cutlass.const_expr(mX.element_type.width == 16):
+        cluster_n = 1 if N <= 16 * 1024 else (2 if N <= 32 * 1024 else (4 if N <= 64 * 1024 else (8 if N <= 128 * 1024 else 16)))
+    else:  # fp32
+        cluster_n = 1 if N <= 16 * 1024 else (2 if N <= 64 * 1024 else (4 if N <= 128 * 1024 else 8))
+
+    num_blocks_N = cute.ceil_div(N // vecsize, threads_per_row * cluster_n)
+    cols_per_block = num_threads // threads_per_row
+    tiler_mn = (cols_per_block, vecsize * num_blocks_N * threads_per_row)  # This rounds up N
+    tv_layout = cute.make_layout(
+        ((threads_per_row, cols_per_block), (vecsize, num_blocks_N)),
+        stride=((vecsize * cols_per_block, 1), (cols_per_block, cols_per_block * vecsize * threads_per_row))
+    )
+
+    smem_allocated = cute.size_in_bytes(mX.element_type, cute.make_layout(tiler_mn)) + 2 * num_warps * cluster_n * (cutlass.Float32.width // 8) + 2 * (cutlass.Int64.width // 8)
+    cross_entropy_kernel(mX, mTarget, mLoss, tv_layout, tiler_mn, cluster_n).launch(
+        grid=[cute.ceil_div(mX.shape[0], tiler_mn[0]), cluster_n, 1],
+        block=[cute.size(tv_layout, mode=[0]), 1, 1],
+        # Launching with cluster=[1, 1, 1] instead of None slows down the kernel by ~8us
+        cluster=[1, cluster_n, 1] if cluster_n > 1 else None,
+        smem=smem_allocated,
+        stream=stream,
+    )
+
+
+torch2cute_dtype_map = {
+    torch.float16: cutlass.Float16,
+    torch.bfloat16: cutlass.BFloat16,
+    torch.float32: cutlass.Float32,
+}
+
+
+def cross_entropy(
+    x: torch.Tensor,
+    target: torch.Tensor,
+) -> torch.Tensor:
+    """Cross entropy forward pass.
+
+    Args:
+        x: Input logits tensor of shape (M, N)
+        target: Target class indices tensor of shape (M,)
+
+    Returns:
+        Cross entropy loss tensor of shape (M,)
+    """
+    assert x.dim() == 2, "Input must be 2D"
+    assert target.dim() == 1, "Target must be 1D"
+    assert x.shape[0] == target.shape[0], "Batch dimensions must match"
+    assert x.is_cuda and target.is_cuda, "Tensors must be on CUDA device"
+    assert x.dtype in [torch.float16, torch.bfloat16, torch.float32], "Unsupported input dtype"
+    assert target.dtype == torch.int64, "Target must be int64"
+    M, N = x.shape
+    device = x.device
+    loss = torch.empty(M, device=device, dtype=x.dtype)
+    dtype = torch2cute_dtype_map[x.dtype]
+    convert_from_dlpack = lambda tensor: (
+        from_dlpack(tensor.detach(), assumed_align=16)
+        .mark_compact_shape_dynamic(mode=0, stride_order=(0, 1))
+    )
+    x_tensor, = [convert_from_dlpack(tensor) for tensor in (x,)]
+    loss_tensor = from_dlpack(loss.detach(), assumed_align=4).mark_compact_shape_dynamic(mode=0)
+    target_tensor = from_dlpack(target.detach(), assumed_align=8).mark_compact_shape_dynamic(mode=0)
+    stream = cuda.CUstream(torch.cuda.current_stream().cuda_stream)
+    compile_key = (dtype, N)
+    if compile_key not in cross_entropy.compile_cache:
+        cross_entropy.compile_cache[compile_key] = cute.compile(
+            cross_entropy_interface, x_tensor, target_tensor, loss_tensor, stream, N
+        )
+    cross_entropy.compile_cache[compile_key](x_tensor, target_tensor, loss_tensor, stream)
+    return loss
+
+
+cross_entropy.compile_cache = {}

quack/rmsnorm.py

@@ -0,0 +1,271 @@
+# Copyright (c) 2025, Wentao Guo, Ted Zadouri, Tri Dao.
+
+import math
+import operator
+
+import torch
+
+import cuda.bindings.driver as cuda
+
+import cutlass
+import cutlass.cute as cute
+from cutlass.cute.runtime import from_dlpack
+
+import quack.utils as utils
+
+
+@cute.kernel
+def rmsnorm_kernel(
+    gX: cute.Tensor,
+    gW: cute.Tensor,
+    gO: cute.Tensor,
+    gRstd: cute.Tensor,
+    cX: cute.Tensor,  # coordinate tensor
+    eps: cute.Float32,
+    shape: cute.Shape,
+    tv_layout: cute.Layout,
+    tiler_mn: cute.Shape,
+    cluster_n: cutlass.Constexpr = 1,
+    reload_from: cutlass.Constexpr = None,
+    delay_w_load: cutlass.Constexpr = False,
+):
+    tidx, _, _ = cute.arch.thread_idx()
+    bidx, cluster_y, _ = cute.arch.block_idx()
+    gdim, _, _ = cute.arch.grid_dim()
+
+    # slice for CTAs
+    # logical id -> address
+    blkX, blkOut, blkRstd, blkCrd = [gT[(None, None), bidx if cluster_n == 1 else (bidx, cluster_y)] for gT in (gX, gO, gRstd, cX)]
+    blkW = gW[(None, None), 0 if cluster_n == 1 else (0, cluster_y)]
+
+    # declare the atoms which will be used later for memory copy
+    copy_atom_load_X = cute.make_copy_atom(cute.nvgpu.CopyUniversalOp(), gX.element_type, num_bits_per_copy=128)
+    copy_atom_load_X_async = cute.make_copy_atom(cute.nvgpu.cpasync.CopyG2SOp(), gX.element_type, num_bits_per_copy=128)
+    copy_atom_load_W = cute.make_copy_atom(cute.nvgpu.CopyUniversalOp(), gW.element_type, num_bits_per_copy=128)
+    copy_atom_store_O = cute.make_copy_atom(cute.nvgpu.CopyUniversalOp(), gO.element_type, num_bits_per_copy=128)
+
+    thr_copy_X = cute.make_tiled_copy(copy_atom_load_X, tv_layout, tiler_mn).get_slice(tidx)
+    thr_copy_X_async = cute.make_tiled_copy(copy_atom_load_X_async, tv_layout, tiler_mn).get_slice(tidx)
+    thr_copy_W = cute.make_tiled_copy(copy_atom_load_W, tv_layout, tiler_mn).get_slice(tidx)
+    thr_copy_O = cute.make_tiled_copy(copy_atom_store_O, tv_layout, tiler_mn).get_slice(tidx)
+
+    smem = cutlass.utils.SmemAllocator()
+    # Don't use blkX.layout here, because the stride is N, not N_rounded
+    sX = smem.allocate_tensor(gX.element_type, cute.make_ordered_layout(blkX.shape, order=(1, 0)), byte_alignment=16)
+    num_warps = cute.size(tv_layout, mode=[0]) // cute.arch.WARP_SIZE
+    warps_per_row = utils.max_constexpr(tv_layout.shape[0][0] // cute.arch.WARP_SIZE, 1)
+    # reduction_buffer_layout = cute.make_ordered_layout((num_warps // warps_per_row, warps_per_row), order=(1, 0))
+    reduction_buffer_layout = cute.make_ordered_layout((num_warps // warps_per_row, warps_per_row if cluster_n == 1 else (warps_per_row, cluster_n)), order=(1, 0))
+    reduction_buffer = smem.allocate_tensor(cutlass.Float32, reduction_buffer_layout, byte_alignment=4)
+    if cutlass.const_expr(cluster_n > 1):
+        mbar_ptr = smem.allocate(cutlass.Int64.width // 8, byte_alignment=8)
+    else:
+        mbar_ptr = None
+
+    tWgW = thr_copy_W.partition_S(blkW)
+    tXgX = thr_copy_X_async.partition_S(blkX)
+    tXsX = thr_copy_X_async.partition_S(sX)
+    tXgO, tXrRstd = [thr_copy_O.partition_D(blk) for blk in (blkOut, blkRstd)]
+    tXcX = thr_copy_X.partition_S(blkCrd)[(0, None), None, None]
+
+    # allocate fragments for gmem->rmem
+    tWrW = cute.make_fragment_like(tWgW)
+    tXrW = thr_copy_X.retile(tWrW)
+    tXrX, tXrO = [cute.make_fragment_like(thr) for thr in (tXgX, tXgO)]
+
+    if cluster_n > 1:
+        if tidx == 0:
+            cute.arch.mbarrier_init_arrive_cnt(mbar_ptr, 1)
+        cute.arch.mbarrier_init_fence()
+        if tidx == 0:
+            cute.arch.mbarrier_init_tx_bytes(mbar_ptr, num_warps * cluster_n * cutlass.Float32.width // 8)
+        # Cluster arrive after barrier init
+        cute.arch.cluster_arrive_relaxed()
+
+    tXpX = cute.make_fragment_like(tXgX[(0, None), None, None], cutlass.Boolean)
+    for i in range(cute.size(tXpX)):
+        tXpX[i] = cute.elem_less(tXcX[i][1], shape[1])
+    # tXrX.fill(0.0)
+    if tXcX[0][0] < shape[0]:
+        # cute.copy(copy_atom_load_X, tXgX, tXrX, pred=tXpX)
+        cute.copy(copy_atom_load_X_async, tXgX, tXsX, pred=tXpX)
+    cute.arch.cp_async_commit_group()
+
+    tWpW = cute.make_fragment_like(tWgW[(0, None), None, None], cutlass.Boolean)
+    tWcX = thr_copy_W.partition_S(blkCrd)[(0, None), None, None]
+    for i in range(cute.size(tWpW)):
+        tWpW[i] = cute.elem_less(tWcX[i][1], shape[1])
+    if not delay_w_load:
+        cute.copy(copy_atom_load_W, tWgW, tWrW, pred=tWpW)
+
+    cute.arch.cp_async_wait_group(0)
+    cute.autovec_copy(tXsX, tXrX)
+    x = tXrX.load().to(cute.Float32)
+    sum_sq_x = utils.warp_reduce(
+        (x * x).reduce(cute.ReductionOp.ADD, init_val=0.0, reduction_profile=0),
+        operator.add,
+        width=utils.min_constexpr(tv_layout.shape[0][0], cute.arch.WARP_SIZE),
+    )
+    if cutlass.const_expr(cluster_n > 1):
+        cute.arch.cluster_wait()
+    if cutlass.const_expr(warps_per_row > 1 or cluster_n > 1):
+        sum_sq_x = utils.block_or_cluster_reduce(
+            sum_sq_x, operator.add, reduction_buffer, mbar_ptr, init_val=0.0
+        )
+    rstd = utils.rsqrt(sum_sq_x / shape[1] + eps)
+    # Only the thread corresponding to column 0 writes out the rstd to gmem
+    if tXcX[0][1] == 0 and tXcX[0][0] < shape[0]:
+        if cutlass.const_expr(cluster_n == 1):
+            tXrRstd[0] = rstd
+        else:
+            if cute.arch.block_idx_in_cluster() == 0:
+                tXrRstd[0] = rstd
+    if delay_w_load:
+        cute.copy(copy_atom_load_W, tWgW, tWrW, pred=tWpW)
+    if reload_from == "smem":
+        cute.autovec_copy(tXsX, tXrX)
+        x = tXrX.load().to(cute.Float32)
+    elif reload_from == "gmem":
+        cute.copy(copy_atom_load_X, tXgX, tXrX, pred=tXpX)
+        x = tXrX.load().to(cute.Float32)
+    x_hat = x * rstd
+    w = tXrW.load().to(cute.Float32)
+    y = x_hat * w
+    tXrO.store(y.to(tXrO.element_type))
+    tOcX = thr_copy_O.partition_S(blkCrd)[(0, None), None, None]
+    tOpO = cute.make_fragment_like(tXgO[(0, None), None, None], cutlass.Boolean)
+    for i in range(cute.size(tOpO)):
+        tOpO[i] = cute.elem_less(tOcX[i][1], shape[1])
+    if tXcX[0][0] < shape[0]:
+        cute.copy(copy_atom_store_O, tXrO, tXgO, pred=tOpO)
+
+
+@cute.jit
+def rmsnorm_interface(
+    # mX_: cute.Tensor,
+    mX: cute.Tensor,
+    mW: cute.Tensor,
+    mOut: cute.Tensor,
+    mRstd: cute.Tensor,
+    stream: cuda.CUstream,
+    N: cutlass.Constexpr,
+    eps: cutlass.Float32 = 1e-6,
+    copy_bits: cutlass.Constexpr = 128
+):
+    # new_shape = (mX_.shape[0], cute.assume(mX_.shape[1], 128))
+    # breakpoint()
+    # mX = cute.make_tensor(mX_.iterator, cute.make_layout(new_shape, stride=mX_.stride))
+    vecsize = copy_bits // mX.element_type.width
+    assert N % vecsize == 0, f"Input N {N} is not divisible by vector size {vecsize}"
+    num_threads = 128 if N <= 16384 else 256
+    num_warps = num_threads // cute.arch.WARP_SIZE
+    assert num_threads % cute.arch.WARP_SIZE == 0
+    threads_per_row = 8 if N <= 64 else (16 if N <= 128 else (32 if N <= 3072 else (64 if N <= 6144 else (128 if N <= 16384 else 256))))
+    # cluster_n = 4 is faster and cluster_n = 2 for N=64k for some reason
+    # Similarly cluster_n = 8 is faster for N=128k
+    if cutlass.const_expr(mX.element_type.width == 16):
+        cluster_n = 1 if N <= 16 * 1024 else (2 if N <= 32 * 1024 else (4 if N <= 64 * 1024 else (8 if N <= 128 * 1024 else 16)))
+    else:  # fp32
+        cluster_n = 1 if N <= 32 * 1024 else (2 if N <= 64 * 1024 else (4 if N <= 128 * 1024 else (8 if N <= 256 * 1024 else 16)))
+
+    num_blocks_N = cute.ceil_div(N // vecsize, threads_per_row * cluster_n)
+    cols_per_block = num_threads // threads_per_row
+    tiler_mn = (cols_per_block, vecsize * num_blocks_N * threads_per_row)  # This rounds up N
+    tv_layout = cute.make_layout(
+        ((threads_per_row, cols_per_block), (vecsize, num_blocks_N)),
+        stride=((vecsize * cols_per_block, 1), (cols_per_block, cols_per_block * vecsize * threads_per_row))
+    )
+
+    mW_expanded_layout = cute.prepend(mW.layout, cute.make_layout((tiler_mn[0],), stride=(0,)))
+    mW_expanded = cute.make_tensor(mW.iterator, mW_expanded_layout)
+    mRstd_expanded_layout = cute.append(mRstd.layout, cute.make_layout((N,), stride=(0,)))
+    mRstd_expanded = cute.make_tensor(mRstd.iterator, mRstd_expanded_layout)
+    idX = cute.make_identity_tensor(mX.shape)
+    gX, gW, gO, gRstd, cX = [cute.zipped_divide(mT, tiler_mn) for mT in (mX, mW_expanded, mOut, mRstd_expanded, idX)]  # ((TileM,TileN),(RestM,RestN))
+
+    # reload_from = None if N <= 16384 else ("smem" if N <= 32768 else "gmem")
+    reload_from = None if N <= 16384 else "smem"
+    # delay_w_load = N > 64 * 1024
+    delay_w_load = False
+    N_rounded = tiler_mn[1]
+    rmsnorm_kernel(gX, gW, gO, gRstd, cX, eps, mX.shape, tv_layout, tiler_mn, cluster_n, reload_from).launch(
+        grid=[cute.size(gX, mode=[1, 0]), cluster_n, 1],
+        block=[cute.size(tv_layout, mode=[0]), 1, 1],
+        # Launching with cluster=[1, 1, 1] instead of None slows down the kernel by ~8us
+        cluster=[1, cluster_n, 1] if cluster_n > 1 else None,
+        # We don't want to use gX.layout[0] here since that has stride in N, not N_rounded, leading IMA on smem
+        smem=cute.size_in_bytes(mX.element_type, cute.make_layout(gX.shape[0])) + num_warps * cluster_n * (cutlass.Float32.width // 8) + (cutlass.Int64.width // 8),
+        stream=stream,
+    )
+
+
+torch2cute_dtype_map = {
+    torch.float16: cutlass.Float16,
+    torch.bfloat16: cutlass.BFloat16,
+    torch.float32: cutlass.Float32,
+}
+
+
+def rmsnorm(
+    x: torch.Tensor,
+    weight: torch.Tensor,
+    eps: float = 1e-6,
+    return_rstd: bool = False,
+) -> torch.Tensor:
+    """RMSNorm forward pass.
+
+    Args:
+        x: Input tensor of shape (M, N)
+        weight: Weight tensor of shape (N,)
+        eps: Small value for numerical stability
+        return_rstd: Whether to return the reciprocal standard deviation
+
+    Returns:
+        Normalized output tensor of same shape as x
+        If return_rstd is True, also returns rstd tensor of shape (M,)
+    """
+    assert x.dim() == 2, "Input must be 2D"
+    assert weight.dim() == 1, "Weight must be 1D"
+    assert x.shape[-1] == weight.shape[0], "Last dimension of input must match weight dimension"
+    assert x.is_cuda and weight.is_cuda, "Tensors must be on CUDA device"
+    assert x.dtype in [torch.float16, torch.bfloat16, torch.float32], "Unsupported dtype"
+    assert weight.dtype == torch.float32, "Weight must be float32"
+    M, N = x.shape
+    device = x.device
+    out = torch.empty_like(x)
+    rstd = torch.empty(M, device=device, dtype=torch.float32)
+    dtype = torch2cute_dtype_map[x.dtype]
+    convert_from_dlpack = lambda x: (
+        from_dlpack(x.detach(), assumed_align=16)
+        .mark_compact_shape_dynamic(mode=0, stride_order=(0, 1))
+    )
+    x_tensor, out_tensor = [
+        # utils.convert_from_dlpack(t, leading_dim=t.ndim - 1, divisibility=128 // dtype.width)
+        convert_from_dlpack(t)
+        for t in (x, out)
+    ]
+    weight_tensor = utils.convert_from_dlpack(weight.detach(), leading_dim=0, divisibility=128 // cutlass.Float32.width)
+    rstd_tensor = from_dlpack(rstd.detach(), assumed_align=4).mark_layout_dynamic(leading_dim=0)
+    current_stream = cuda.CUstream(torch.cuda.current_stream().cuda_stream)
+    compile_key = (dtype, N)
+    if compile_key not in rmsnorm.compile_cache:
+        rmsnorm.compile_cache[compile_key] = cute.compile(
+            rmsnorm_interface, x_tensor, weight_tensor, out_tensor, rstd_tensor, current_stream, N
+        )
+    rmsnorm.compile_cache[compile_key](
+        x_tensor, weight_tensor, out_tensor, rstd_tensor, current_stream, eps
+    )
+    return (out, rstd) if return_rstd else out
+
+
+rmsnorm.compile_cache = {}
+
+
+def rmsnorm_ref(x, w, eps=1e-6):
+    x_f32 = x.float()
+    return (x_f32 / (torch.sqrt(torch.mean(x_f32 * x_f32, dim=-1, keepdim=True) + eps)) * w).to(x.dtype)
+
+
+def rstd_ref(x, eps=1e-6):
+    x_f32 = x.float()
+    return 1.0 / torch.sqrt(torch.mean(x_f32 * x_f32, dim=-1) + eps)

quack/softmax.py

@@ -0,0 +1,202 @@
+import math
+import torch
+import operator
+from typing import Callable
+
+import cuda.bindings.driver as cuda
+
+import cutlass
+import cutlass.cute as cute
+from cutlass.cute.runtime import from_dlpack
+import cutlass.torch as cutlass_torch
+
+import quack.utils as utils
+
+
+@cute.kernel
+def softmax_kernel(
+    gX: cute.Tensor,
+    gO: cute.Tensor,
+    cX: cute.Tensor,  # coordinate tensor
+    shape: cute.Shape,
+    tv_layout: cute.Layout,
+    tiler_mn: cute.Shape,
+    cluster_n: cutlass.Constexpr = 1,
+):
+    tidx, _, _ = cute.arch.thread_idx()
+    bidx, cluster_y, _ = cute.arch.block_idx()
+    gdim, _, _ = cute.arch.grid_dim()
+
+    # slice for CTAs
+    # logical id -> address
+    blkX, blkOut, blkCrd = [gT[(None, None), bidx if cluster_n == 1 else (bidx, cluster_y)] for gT in (gX, gO, cX)]
+
+    # declare the atoms which will be used later for memory copy
+    copy_atom_load_X = cute.make_copy_atom(cute.nvgpu.CopyUniversalOp(), gX.element_type, num_bits_per_copy=128)
+    copy_atom_load_X_async = cute.make_copy_atom(cute.nvgpu.cpasync.CopyG2SOp(), gX.element_type, num_bits_per_copy=128)
+    copy_atom_store_O = cute.make_copy_atom(cute.nvgpu.CopyUniversalOp(), gO.element_type, num_bits_per_copy=128)
+
+    thr_copy_X = cute.make_tiled_copy(copy_atom_load_X, tv_layout, tiler_mn).get_slice(tidx)
+    thr_copy_X_async = cute.make_tiled_copy(copy_atom_load_X_async, tv_layout, tiler_mn).get_slice(tidx)
+    thr_copy_O = cute.make_tiled_copy(copy_atom_store_O, tv_layout, tiler_mn).get_slice(tidx)
+
+    smem = cutlass.utils.SmemAllocator()
+    # Don't use blkX.layout here, because the stride is N, not N_rounded
+    sX = smem.allocate_tensor(gX.element_type, cute.make_ordered_layout(blkX.shape, order=(1, 0)), byte_alignment=16)
+    num_warps = cute.size(tv_layout, mode=[0]) // cute.arch.WARP_SIZE
+    warps_per_row = utils.max_constexpr(tv_layout.shape[0][0] // cute.arch.WARP_SIZE, 1)
+
+    reduction_buffer_layout = cute.make_ordered_layout(
+        # 2 stages: 1 for max, 1 for sum
+        (num_warps // warps_per_row, warps_per_row if cluster_n == 1 else (warps_per_row, cluster_n), 2),
+        order=(1, 0, 2)
+    )
+    reduction_buffer = smem.allocate_tensor(cutlass.Float32, reduction_buffer_layout, byte_alignment=4)
+    if cutlass.const_expr(cluster_n > 1):
+        # 1 mbar for max reduction, 1 mbar for sum reduction
+        mbar_ptr = smem.allocate_array(cutlass.Int64, num_elems=2)
+    else:
+        mbar_ptr = None
+
+    tXgX = thr_copy_X_async.partition_S(blkX)
+    tXsX = thr_copy_X_async.partition_S(sX)
+    tXgO = thr_copy_O.partition_D(blkOut)
+    tXcX = thr_copy_X.partition_S(blkCrd)[(0, None), None, None]
+
+    # allocate fragments for gmem->rmem
+    tXrX, tXrO = [cute.make_fragment_like(thr) for thr in (tXgX, tXgO)]
+
+    if cluster_n > 1:
+        if tidx < 2:
+            cute.arch.mbarrier_init_arrive_cnt(mbar_ptr + tidx, 1)
+        cute.arch.mbarrier_init_fence()
+        if tidx < 2:
+            cute.arch.mbarrier_init_tx_bytes(mbar_ptr + tidx, num_warps * cluster_n * cutlass.Float32.width // 8)
+        # Cluster arrive after barrier init
+        cute.arch.cluster_arrive_relaxed()
+
+    tXpX = cute.make_fragment_like(tXgX[(0, None), None, None], cutlass.Boolean)
+    for i in range(cute.size(tXpX)):
+        tXpX[i] = cute.elem_less(tXcX[i][1], shape[1])
+
+    if tXcX[0][0] < shape[0]:
+        cute.copy(copy_atom_load_X_async, tXgX, tXsX, pred=tXpX)
+    cute.arch.cp_async_commit_group()
+    cute.arch.cp_async_wait_group(0)
+
+    cute.autovec_copy(tXsX, tXrX)
+    x = tXrX.load().to(cute.Float32)
+    max_x = utils.warp_reduce(
+        x.reduce(cute.ReductionOp.MAX, init_val=float('-inf'), reduction_profile=0),
+        cute.arch.fmax,
+        width=utils.min_constexpr(tv_layout.shape[0][0], cute.arch.WARP_SIZE),
+    )
+    if cutlass.const_expr(cluster_n > 1):
+        cute.arch.cluster_wait()
+    if cutlass.const_expr(warps_per_row > 1 or cluster_n > 1):
+        max_mbar_ptr = mbar_ptr + 0 if cluster_n > 1 else None
+        max_x = utils.block_or_cluster_reduce(
+            max_x, cute.arch.fmax, reduction_buffer[None, None, 0], max_mbar_ptr, init_val=-cutlass.Float32.inf
+        )
+    log2_e = math.log2(math.e)
+    exp_x = cute.math.exp2((x - max_x) * log2_e, fastmath=True)
+    denom = utils.warp_reduce(
+        exp_x.reduce(cute.ReductionOp.ADD, init_val=0.0, reduction_profile=0),
+        operator.add,
+        width=utils.min_constexpr(tv_layout.shape[0][0], cute.arch.WARP_SIZE),
+    )
+    if cutlass.const_expr(warps_per_row > 1 or cluster_n > 1):
+        sum_mbar_ptr = mbar_ptr + 1 if cluster_n > 1 else None
+        denom = utils.block_or_cluster_reduce(
+            denom, operator.add, reduction_buffer[None, None, 1], sum_mbar_ptr, init_val=0.0
+        )
+    inv = 1.0 / denom
+    y = exp_x * inv
+
+    tXrO.store(y.to(tXrO.element_type))
+    tOcX = thr_copy_O.partition_S(blkCrd)[(0, None), None, None]
+    tOpO = cute.make_fragment_like(tXgO[(0, None), None, None], cutlass.Boolean)
+    for i in range(cute.size(tOpO)):
+        tOpO[i] = cute.elem_less(tOcX[i][1], shape[1])
+    if tXcX[0][0] < shape[0]:
+        cute.copy(copy_atom_store_O, tXrO, tXgO, pred=tOpO)
+
+
+@cute.jit
+def softmax_interface(
+    mX: cute.Tensor,
+    mOut: cute.Tensor,
+    stream: cuda.CUstream,
+    N: cutlass.Constexpr,
+    copy_bits: cutlass.Constexpr = 128
+):
+    vecsize = copy_bits // mX.element_type.width
+    assert N % vecsize == 0, f"Input N {N} is not divisible by vector size {vecsize}"
+    num_threads = 128 if N <= 16384 else 256
+    num_warps = num_threads // cute.arch.WARP_SIZE
+    assert num_threads % cute.arch.WARP_SIZE == 0
+    threads_per_row = 8 if N <= 64 else (16 if N <= 128 else (32 if N <= 3072 else (64 if N <= 6144 else (128 if N <= 16384 else 256))))
+    if cutlass.const_expr(mX.element_type.width == 16):
+        cluster_n = 1 if N <= 16 * 1024 else (2 if N <= 32 * 1024 else (4 if N <= 64 * 1024 else (8 if N <= 128 * 1024 else 16)))
+    else:  # fp32
+        cluster_n = 1 if N <= 32 * 1024 else (2 if N <= 64 * 1024 else (4 if N <= 128 * 1024 else (8 if N <= 256 * 1024 else 16)))
+
+    num_blocks_N = cute.ceil_div(N // vecsize, threads_per_row * cluster_n)
+    cols_per_block = num_threads // threads_per_row
+    tiler_mn = (cols_per_block, vecsize * num_blocks_N * threads_per_row)  # This rounds up N
+    tv_layout = cute.make_layout(
+        ((threads_per_row, cols_per_block), (vecsize, num_blocks_N)),
+        stride=((vecsize * cols_per_block, 1), (cols_per_block, cols_per_block * vecsize * threads_per_row))
+    )
+
+    idX = cute.make_identity_tensor(mX.shape)
+    gX, gO, cX = [cute.zipped_divide(mT, tiler_mn) for mT in (mX, mOut, idX)]  # ((TileM,TileN),(RestM,RestN))
+
+    smem_allocated = cute.size_in_bytes(mX.element_type, cute.make_layout(gX.shape[0])) + 2 * num_warps * cluster_n * (cutlass.Float32.width // 8) + 2 * (cutlass.Int64.width // 8)
+    softmax_kernel(gX, gO, cX, mX.shape, tv_layout, tiler_mn, cluster_n).launch(
+        grid=[cute.size(gX, mode=[1, 0]), cluster_n, 1],
+        block=[cute.size(tv_layout, mode=[0]), 1, 1],
+        # Launching with cluster=[1, 1, 1] instead of None slows down the kernel by ~8us
+        cluster=[1, cluster_n, 1] if cluster_n > 1 else None,
+        smem=smem_allocated,
+        stream=stream,
+    )
+
+
+torch2cute_dtype_map = {
+    torch.float16: cutlass.Float16,
+    torch.bfloat16: cutlass.BFloat16,
+    torch.float32: cutlass.Float32,
+}
+
+
+def softmax(x: torch.Tensor) -> torch.Tensor:
+    """Softmax forward pass.
+    Args:
+        x: Input tensor of shape (M, N)
+    Returns:
+        Softmax output tensor of same shape as x
+    """
+    assert x.dim() == 2, "Input must be 2D"
+    assert x.is_cuda, "Tensor must be on CUDA device"
+    assert x.dtype in [torch.float16, torch.bfloat16, torch.float32], "Unsupported dtype"
+    M, N = x.shape
+    device = x.device
+    out = torch.empty_like(x)
+    dtype = torch2cute_dtype_map[x.dtype]
+    convert_from_dlpack = lambda tensor: (
+        from_dlpack(tensor.detach(), assumed_align=16)
+        .mark_compact_shape_dynamic(mode=0, stride_order=(0, 1))
+    )
+    x_tensor, out_tensor = [convert_from_dlpack(tensor) for tensor in (x, out)]
+    current_stream = cuda.CUstream(torch.cuda.current_stream().cuda_stream)
+    compile_key = (dtype, N)
+    if compile_key not in softmax.compile_cache:
+        softmax.compile_cache[compile_key] = cute.compile(
+            softmax_interface, x_tensor, out_tensor, current_stream, N
+        )
+    softmax.compile_cache[compile_key](x_tensor, out_tensor, current_stream)
+    return out
+
+
+softmax.compile_cache = {}

quack/utils.py

@@ -0,0 +1,190 @@
+# Copyright (c) 2025, Wentao Guo, Ted Zadouri, Tri Dao.
+
+import math
+from typing import Type, Callable, Optional
+
+import cutlass
+import cutlass.cute as cute
+
+from cutlass.cutlass_dsl import T, dsl_user_op
+from cutlass._mlir.dialects import nvvm, llvm
+from cutlass.cute.runtime import from_dlpack
+
+
+def convert_from_dlpack(x, leading_dim, alignment=16, divisibility=1) -> cute.Tensor:
+    return (
+        from_dlpack(x, assumed_align=alignment)
+        .mark_layout_dynamic(leading_dim=leading_dim)
+        .mark_compact_shape_dynamic(
+            mode=leading_dim, stride_order=x.dim_order(), divisibility=divisibility
+        )
+    )
+
+
+@cute.jit
+def max_constexpr(
+    a: cutlass.Constexpr[cute.Numeric], b: cutlass.Constexpr[cute.Numeric]
+) -> cutlass.Constexpr[cute.Numeric]:
+    return a if a > b else b
+
+
+@cute.jit
+def min_constexpr(
+    a: cutlass.Constexpr[cute.Numeric], b: cutlass.Constexpr[cute.Numeric]
+) -> cutlass.Constexpr[cute.Numeric]:
+    return a if a < b else b
+
+
+def warp_reduce(
+    val: cute.TensorSSA | cute.Numeric,
+    op: Callable,
+    width: cutlass.Constexpr[int] = cute.arch.WARP_SIZE
+) -> cute.TensorSSA | cute.Numeric:
+    if isinstance(val, cute.TensorSSA):
+        res = cute.make_fragment(val.shape, val.dtype)
+        res.store(val)
+        for i in range(cute.size(val.shape)):
+            res[i] = warp_reduce(res[i], op, width)
+        return res.load()
+    else:
+        for i in range(int(math.log2(width))):
+            val = op(val, cute.arch.shuffle_sync_bfly(val, offset=1 << i))
+    return val
+
+
+@cute.jit
+def block_reduce(val: cute.Numeric, op: Callable, reduction_buffer: cute.Tensor, init_val: cute.Numeric = 0.0) -> cute.Numeric:
+    """reduction_buffer has shape (num_warps / warp_per_row, warps_per_row)
+    """
+    lane_idx, warp_idx = cute.arch.lane_idx(), cute.arch.warp_idx()
+    warps_per_row = reduction_buffer.shape[1]
+    row_idx, col_idx = warp_idx // warps_per_row, warp_idx % warps_per_row
+    if lane_idx == 0:
+        reduction_buffer[row_idx, col_idx] = val
+    cute.arch.barrier()
+    block_reduce_val = init_val
+    if lane_idx < warps_per_row:
+        block_reduce_val = reduction_buffer[row_idx, lane_idx]
+    return warp_reduce(block_reduce_val, op)
+
+
+@dsl_user_op
+def elem_pointer(x: cute.Tensor, coord: cute.Coord, *, loc=None, ip=None) -> cute.Pointer:
+    return x.iterator + cute.crd2idx(coord, x.layout, loc=loc, ip=ip)
+
+
+@dsl_user_op
+def set_block_rank(smem_ptr: cute.Pointer, peer_cta_rank_in_cluster: cute.Int32, *, loc=None, ip=None) -> cutlass.Int32:
+    """Map the given smem pointer to the address at another CTA rank in the cluster.
+    """
+    smem_ptr_i32 = smem_ptr.toint(loc=loc, ip=ip).ir_value()
+    return cutlass.Int32(
+        llvm.inline_asm(
+            T.i32(),
+            [smem_ptr_i32, peer_cta_rank_in_cluster.ir_value()],
+            "mapa.shared::cluster.u32 $0, $1, $2;",
+            "=r,r,r",
+            has_side_effects=False,
+            is_align_stack=False,
+            asm_dialect=llvm.AsmDialect.AD_ATT,
+        )
+    )
+
+
+@dsl_user_op
+def store_shared_remote(
+    val: float | cute.Float32, smem_ptr: cute.Pointer, mbar_ptr: cute.Pointer,
+    peer_cta_rank_in_cluster: cute.typing.Int, *, loc=None, ip=None
+) -> None:
+    remote_smem_ptr_i32 = set_block_rank(smem_ptr, peer_cta_rank_in_cluster, loc=loc, ip=ip).ir_value()
+    remote_mbar_ptr_i32 = set_block_rank(mbar_ptr, peer_cta_rank_in_cluster, loc=loc, ip=ip).ir_value()
+    llvm.inline_asm(
+        None,
+        [remote_smem_ptr_i32, cute.Float32(val).ir_value(loc=loc, ip=ip), remote_mbar_ptr_i32],
+        "st.async.shared::cluster.mbarrier::complete_tx::bytes.f32 [$0], $1, [$2];",
+        "r,f,r",
+        has_side_effects=True,
+        is_align_stack=False,
+        asm_dialect=llvm.AsmDialect.AD_ATT,
+    )
+
+
+@cute.jit
+def cluster_reduce(val: cute.Numeric, op: Callable, reduction_buffer: cute.Tensor, mbar_ptr: cute.Pointer, init_val: cute.Numeric = 0.0) -> cute.Numeric:
+    """reduction_buffer has shape (num_warps / warps_per_row, (warps_per_row, cluster_n))
+    """
+    cta_rank_in_cluster = cute.arch.block_idx_in_cluster()
+    lane_idx, warp_idx = cute.arch.lane_idx(), cute.arch.warp_idx()
+    warps_per_row, cluster_n = reduction_buffer.shape[1]
+    row_idx, col_idx = warp_idx // warps_per_row, warp_idx % warps_per_row
+    if lane_idx < cluster_n:
+        store_shared_remote(
+            val, elem_pointer(reduction_buffer, (row_idx, (col_idx, cta_rank_in_cluster))),
+            mbar_ptr, peer_cta_rank_in_cluster=lane_idx
+        )
+    cute.arch.mbarrier_wait(mbar_ptr, phase=0)
+    block_reduce_val = init_val
+    num_iter = cute.ceil_div(warps_per_row * cluster_n, cute.arch.WARP_SIZE)
+    for i in cutlass.range_constexpr(num_iter):
+        idx = lane_idx + i * cute.arch.WARP_SIZE
+        if idx < cute.size(reduction_buffer, mode=[1]):
+            block_reduce_val = op(block_reduce_val, reduction_buffer[row_idx, idx])
+    return warp_reduce(block_reduce_val, op)
+
+
+@cute.jit
+def block_or_cluster_reduce(val: cute.Numeric, op: Callable, reduction_buffer: cute.Tensor, mbar_ptr: Optional[cute.Pointer], init_val: cute.Numeric = 0.0) -> cute.Numeric:
+    """Perform either block or cluster reduction based on whether mbar_ptr is provided.
+    """
+    if cutlass.const_expr(mbar_ptr is None):
+        return block_reduce(val, op, reduction_buffer, init_val=init_val)
+    else:
+        return cluster_reduce(val, op, reduction_buffer, mbar_ptr, init_val=init_val)
+
+
+def exp2f(x: cute.TensorSSA | cutlass.Float32) -> cute.TensorSSA | cutlass.Float32:
+    """exp2f calculation for both vector and scalar.
+
+    :param x: input value
+    :type x: cute.TensorSSA or cutlass.Float32
+    :return: exp2 value
+    :rtype: cute.TensorSSA or cutlass.Float32
+    """
+    if isinstance(x, cute.TensorSSA):
+        res = cute.make_fragment(x.shape, cutlass.Float32)
+        res.store(x)
+        for i in range(cute.size(x.shape)):
+            res[i] = cute.arch.exp2(res[i])
+        return res.load()
+    else:
+        return cute.arch.exp2(x)
+
+
+@dsl_user_op
+def log2f(a: float | cutlass.Float32, *, loc=None, ip=None) -> cutlass.Float32:
+    return cutlass.Float32(
+        llvm.inline_asm(
+            T.f32(),
+            [cutlass.Float32(a).ir_value(loc=loc, ip=ip)],
+            "lg2.approx.ftz.f32 $0, $1;",
+            "=f,f",
+            has_side_effects=False,
+            is_align_stack=False,
+            asm_dialect=llvm.AsmDialect.AD_ATT,
+        )
+    )
+
+
+@dsl_user_op
+def rsqrt(a: float | cute.Float32, *, loc=None, ip=None) -> cute.Float32:
+    return cute.Float32(
+        llvm.inline_asm(
+            T.f32(),
+            [cute.Float32(a).ir_value(loc=loc, ip=ip)],
+            "rsqrt.approx.ftz.f32 $0, $1;",
+            "=f,f",
+            has_side_effects=False,
+            is_align_stack=False,
+            asm_dialect=llvm.AsmDialect.AD_ATT,
+        )
+    )

quack_kernels-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: quack-kernels
+Version: 0.1.0
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: nvidia-cutlass-dsl==4.0.0
+Dynamic: license-file

quack_kernels-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+quack/__init__.py,sha256=ByNPsC-VY-f9BAa8IIS6dXlrwBQnzPPTiQqAZY6rYB8,137
+quack/cross_entropy.py,sha256=V0kG8DCNh2735sPIDwe68NB50rAqDF3XQApnGyo-sKg,9220
+quack/rmsnorm.py,sha256=RNqcT-q4uvMbF6ejpzuqQH8l8VVuTRlnueXf28V47sc,11954
+quack/softmax.py,sha256=QABgOESH5JjDm3yuUkyZZKXXpzn7CTuMSs0NEBnFD80,8536
+quack/utils.py,sha256=ofV7QLDuq80h3nEA3TwZW-ti8CnYwMgnz1dpxpvhHpk,6859
+quack_kernels-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+quack_kernels-0.1.0.dist-info/METADATA,sha256=M4DjZ2lD1in6Wo9cPeAXiT0fY9sDxX1m9RQtR5b8OFg,165
+quack_kernels-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+quack_kernels-0.1.0.dist-info/top_level.txt,sha256=6e4Jr_vNJbZTYwlO_Ahf_sDeHDE0zcqcf7Le11FKxxo,6
+quack_kernels-0.1.0.dist-info/RECORD,,

quack_kernels-0.1.0.dist-info/WHEEL

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

quack_kernels-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

quack_kernels-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+quack