Add files using upload-large-folder tool

upstream/CoDA/coda.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: coda
+Version: 1.0.0
+Summary: ['CoDA training and inference']
+Home-page: https://github.com/phj128/CoDA
+Author: Huaijin Pi
+Dynamic: author
+Dynamic: home-page
+Dynamic: summary

upstream/CoDA/coda.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+coda/__init__.py
+coda.egg-info/PKG-INFO
+coda.egg-info/SOURCES.txt
+coda.egg-info/dependency_links.txt
+coda.egg-info/top_level.txt
+coda/configs/__init__.py
+coda/configs/store_coda.py

upstream/CoDA/coda.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

upstream/CoDA/coda.egg-info/top_level.txt

@@ -0,0 +1 @@
+coda

upstream/CoDA/coda/__init__.py

@@ -0,0 +1,9 @@
+import os
+from pathlib import Path
+
+PROJ_ROOT = Path(__file__).resolve().parents[1]
+
+
+def os_chdir_to_proj_root():
+    """useful for running notebooks in different directories."""
+    os.chdir(PROJ_ROOT)

upstream/CoDA/outputs/test_arctic/diffusionwholebody/.hydra/overrides.yaml

@@ -0,0 +1,4 @@
+- exp=wholebody/obj_arctic
+- global/task=wholebody/test_arctic
+- +pl_trainer.limit_test_batches=1
+- seed=43

upstream/flash-linear-attention/benchmarks/ops/benchmark.py

@@ -0,0 +1,268 @@
+# Copyright (c) 2023, Tri Dao.
+""" Useful functions for writing test code. """
+
+import torch
+import torch.utils.benchmark as benchmark
+
+
+def benchmark_forward(
+    fn, *inputs, repeats=10, desc="", verbose=True, amp=False, amp_dtype=torch.float16, **kwinputs
+):
+    """Use Pytorch Benchmark on the forward pass of an arbitrary function."""
+    if verbose:
+        print(desc, "- Forward pass")
+
+    def amp_wrapper(*inputs, **kwinputs):
+        with torch.autocast(device_type="cuda", dtype=amp_dtype, enabled=amp):
+            fn(*inputs, **kwinputs)
+
+    t = benchmark.Timer(
+        stmt="fn_amp(*inputs, **kwinputs)",
+        globals={"fn_amp": amp_wrapper, "inputs": inputs, "kwinputs": kwinputs},
+        num_threads=torch.get_num_threads(),
+    )
+    m = t.timeit(repeats)
+    if verbose:
+        print(m)
+    return t, m
+
+
+def benchmark_backward(
+    fn,
+    *inputs,
+    grad=None,
+    repeats=10,
+    desc="",
+    verbose=True,
+    amp=False,
+    amp_dtype=torch.float16,
+    **kwinputs,
+):
+    """Use Pytorch Benchmark on the backward pass of an arbitrary function."""
+    if verbose:
+        print(desc, "- Backward pass")
+    with torch.autocast(device_type="cuda", dtype=amp_dtype, enabled=amp):
+        y = fn(*inputs, **kwinputs)
+        if type(y) is tuple:
+            y = y[0]
+    if grad is None:
+        grad = torch.randn_like(y)
+    else:
+        if grad.shape != y.shape:
+            raise RuntimeError("Grad shape does not match output shape")
+
+    def f(*inputs, y, grad):
+        # Set .grad to None to avoid extra operation of gradient accumulation
+        for x in inputs:
+            if isinstance(x, torch.Tensor):
+                x.grad = None
+        y.backward(grad, retain_graph=True)
+
+    t = benchmark.Timer(
+        stmt="f(*inputs, y=y, grad=grad)",
+        globals={"f": f, "inputs": inputs, "y": y, "grad": grad},
+        num_threads=torch.get_num_threads(),
+    )
+    m = t.timeit(repeats)
+    if verbose:
+        print(m)
+    return t, m
+
+
+def benchmark_combined(
+    fn,
+    *inputs,
+    grad=None,
+    repeats=10,
+    desc="",
+    verbose=True,
+    amp=False,
+    amp_dtype=torch.float16,
+    **kwinputs,
+):
+    """Use Pytorch Benchmark on the forward+backward pass of an arbitrary function."""
+    if verbose:
+        print(desc, "- Forward + Backward pass")
+    with torch.autocast(device_type="cuda", dtype=amp_dtype, enabled=amp):
+        y = fn(*inputs, **kwinputs)
+        if type(y) is tuple:
+            y = y[0]
+    if grad is None:
+        grad = torch.randn_like(y)
+    else:
+        if grad.shape != y.shape:
+            raise RuntimeError("Grad shape does not match output shape")
+
+    def f(grad, *inputs, **kwinputs):
+        for x in inputs:
+            if isinstance(x, torch.Tensor):
+                x.grad = None
+        with torch.autocast(device_type="cuda", dtype=amp_dtype, enabled=amp):
+            y = fn(*inputs, **kwinputs)
+            if type(y) is tuple:
+                y = y[0]
+        y.backward(grad, retain_graph=True)
+
+    t = benchmark.Timer(
+        stmt="f(grad, *inputs, **kwinputs)",
+        globals={"f": f, "fn": fn, "inputs": inputs, "grad": grad, "kwinputs": kwinputs},
+        num_threads=torch.get_num_threads(),
+    )
+    m = t.timeit(repeats)
+    if verbose:
+        print(m)
+    return t, m
+
+
+def benchmark_fwd_bwd(
+    fn,
+    *inputs,
+    grad=None,
+    repeats=10,
+    desc="",
+    verbose=True,
+    amp=False,
+    amp_dtype=torch.float16,
+    **kwinputs,
+):
+    """Use Pytorch Benchmark on the forward+backward pass of an arbitrary function."""
+    return (
+        benchmark_forward(
+            fn,
+            *inputs,
+            repeats=repeats,
+            desc=desc,
+            verbose=verbose,
+            amp=amp,
+            amp_dtype=amp_dtype,
+            **kwinputs,
+        ),
+        benchmark_backward(
+            fn,
+            *inputs,
+            grad=grad,
+            repeats=repeats,
+            desc=desc,
+            verbose=verbose,
+            amp=amp,
+            amp_dtype=amp_dtype,
+            **kwinputs,
+        ),
+    )
+
+
+def benchmark_all(
+    fn,
+    *inputs,
+    grad=None,
+    repeats=10,
+    desc="",
+    verbose=True,
+    amp=False,
+    amp_dtype=torch.float16,
+    **kwinputs,
+):
+    """Use Pytorch Benchmark on the forward+backward pass of an arbitrary function."""
+    return (
+        benchmark_forward(
+            fn,
+            *inputs,
+            repeats=repeats,
+            desc=desc,
+            verbose=verbose,
+            amp=amp,
+            amp_dtype=amp_dtype,
+            **kwinputs,
+        ),
+        benchmark_backward(
+            fn,
+            *inputs,
+            grad=grad,
+            repeats=repeats,
+            desc=desc,
+            verbose=verbose,
+            amp=amp,
+            amp_dtype=amp_dtype,
+            **kwinputs,
+        ),
+        benchmark_combined(
+            fn,
+            *inputs,
+            grad=grad,
+            repeats=repeats,
+            desc=desc,
+            verbose=verbose,
+            amp=amp,
+            amp_dtype=amp_dtype,
+            **kwinputs,
+        ),
+    )
+
+
+def pytorch_profiler(
+    fn,
+    *inputs,
+    trace_filename=None,
+    backward=False,
+    amp=False,
+    amp_dtype=torch.float16,
+    cpu=False,
+    verbose=True,
+    **kwinputs,
+):
+    """Wrap benchmark functions in Pytorch profiler to see CUDA information."""
+    if backward:
+        with torch.autocast(device_type="cuda", dtype=amp_dtype, enabled=amp):
+            out = fn(*inputs, **kwinputs)
+            if type(out) is tuple:
+                out = out[0]
+            g = torch.randn_like(out)
+    for _ in range(30):  # Warm up
+        if backward:
+            for x in inputs:
+                if isinstance(x, torch.Tensor):
+                    x.grad = None
+        with torch.autocast(device_type="cuda", dtype=amp_dtype, enabled=amp):
+            out = fn(*inputs, **kwinputs)
+            if type(out) is tuple:
+                out = out[0]
+        # Backward should be done outside autocast
+        if backward:
+            out.backward(g, retain_graph=True)
+    activities = ([torch.profiler.ProfilerActivity.CPU] if cpu else []) + [
+        torch.profiler.ProfilerActivity.CUDA
+    ]
+    with torch.profiler.profile(
+        activities=activities,
+        record_shapes=True,
+        # profile_memory=True,
+        with_stack=True,
+    ) as prof:
+        if backward:
+            for x in inputs:
+                if isinstance(x, torch.Tensor):
+                    x.grad = None
+        with torch.autocast(device_type="cuda", dtype=amp_dtype, enabled=amp):
+            out = fn(*inputs, **kwinputs)
+            if type(out) is tuple:
+                out = out[0]
+        if backward:
+            out.backward(g, retain_graph=True)
+    if verbose:
+        # print(prof.key_averages().table(sort_by="self_cuda_time_total", row_limit=50))
+        print(prof.key_averages().table(row_limit=50))
+    if trace_filename is not None:
+        prof.export_chrome_trace(trace_filename)
+
+
+def benchmark_memory(fn, *inputs, desc="", verbose=True, **kwinputs):
+    torch.cuda.empty_cache()
+    torch.cuda.reset_peak_memory_stats()
+    torch.cuda.synchronize()
+    fn(*inputs, **kwinputs)
+    torch.cuda.synchronize()
+    mem = torch.cuda.max_memory_allocated() / ((2**20) * 1000)
+    if verbose:
+        print(f"{desc} max memory: {mem}GB")
+    torch.cuda.empty_cache()
+    return mem

upstream/flash-linear-attention/benchmarks/ops/benchmark_based.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+
+import torch
+import triton
+
+from fla.ops.based import fused_chunk_based, parallel_based
+from fla.ops.based.naive import naive_chunk_based, naive_parallel_based
+
+try:
+    from flash_attn import flash_attn_func
+    HAS_FLASH = True
+except Exception:
+    HAS_FLASH = False
+
+
+@triton.testing.perf_report(
+    triton.testing.Benchmark(
+        # argument names to use as an x-axis for the plot
+        x_names=['T'],
+        # different possible values for `x_name`
+        x_vals=[128 * 2 ** i for i in range(3, 8)],
+        # argument name whose value corresponds to a different line in the plot
+        line_arg='provider',
+        line_vals=['fused_chunk', 'torch', 'parallel', 'parallel_chunk', 'fused_chunk_bwd', 'torch_bwd',
+                   'parallel_bwd', 'parallel_chunk_bwd'] + (['flash', 'flash_bwd'] if HAS_FLASH else []),
+        # label name for the lines
+        line_names=['fused_chunk_fwd', 'torch_fwd', 'parallel_fwd',  'parallel_chunk_fwd',
+                    'fused_chunk_fwdbwd', 'torch_fwdbwd', 'parallel_fwdbwd',
+                    'parallel_chunk_fwdbwd'] + (['flash_fwd', 'flash_fwdbwd'] if HAS_FLASH else []),
+
+        # line styles
+        styles=[('green', '-'), ('blue', '-'), ('red', '-'), ('green', 'dotted'), ('blue', 'dotted'),
+                ('red', 'dotted'), ('red', '--'), ('red', ':')] + ([('cyan', '-'), ('cyan', 'dotted')] if HAS_FLASH else []),
+        ylabel="Execution Time (ms)",  # label name for the y-axis
+        # name for the plot. Used also as a file name for saving the plot.
+        plot_name="Performance",
+        args={},
+    )
+)
+def benchmark(T, provider):
+    from fla.utils import device
+    dtype = torch.bfloat16
+    requires_grad = True
+    B, H, D = 8, 16, 128
+
+    if provider == 'flash' or provider == 'flash_bwd':
+        q = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        k = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        v = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    else:
+        q = torch.randn(B, H, T, 16, device=device, requires_grad=requires_grad, dtype=dtype)
+        k = torch.randn(B, H, T, 16, device=device, requires_grad=requires_grad, dtype=dtype)
+        v = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    do = torch.ones_like(v, dtype=dtype)
+
+    quantiles = [0.5, 0.2, 0.8]
+    results = 0, 0, 0
+    if provider == 'torch':
+        if T > 1024:
+            return results
+        results = triton.testing.do_bench(lambda: naive_parallel_based(q, k, v), quantiles=quantiles)
+    elif provider == 'fused_chunk':
+        results = triton.testing.do_bench(lambda: fused_chunk_based(q, k, v), quantiles=quantiles)
+    elif provider == 'parallel':
+        results = triton.testing.do_bench(lambda: parallel_based(q, k, v), quantiles=quantiles)
+    elif provider == 'parallel_chunk':
+        results = triton.testing.do_bench(lambda: naive_chunk_based(q, k, v), quantiles=quantiles)
+    elif provider == 'torch_bwd':
+        if T > 1024:
+            return results
+        results = triton.testing.do_bench(lambda: naive_parallel_based(q, k, v).backward(do), quantiles=quantiles)
+    elif provider == 'fused_chunk_bwd':
+        results = triton.testing.do_bench(lambda: fused_chunk_based(q, k, v).backward(do), quantiles=quantiles)
+    elif provider == 'parallel_bwd':
+        results = triton.testing.do_bench(lambda: parallel_based(q, k, v).backward(do), quantiles=quantiles)
+    elif provider == 'flash':
+        results = triton.testing.do_bench(lambda: flash_attn_func(q, k, v, causal=True), quantiles=quantiles)
+    elif provider == 'flash_bwd':
+        results = triton.testing.do_bench(lambda: flash_attn_func(q, k, v, causal=True).backward(do), quantiles=quantiles)
+    elif provider == 'parallel_chunk_bwd':
+        results = triton.testing.do_bench(lambda: naive_chunk_based(q, k, v).backward(do), quantiles=quantiles)
+    return results
+
+
+if __name__ == '__main__':
+    benchmark.run(print_data=True, show_plots=True)

upstream/flash-linear-attention/benchmarks/ops/benchmark_delta_rule.py

@@ -0,0 +1,94 @@
+# Install the newest triton version with
+# pip install "git+https://github.com/openai/triton.git#egg=triton&subdirectory=python"
+
+import torch
+from benchmark import benchmark_backward, benchmark_combined, benchmark_forward
+from torch.nn import functional as F
+
+from fla.ops.delta_rule import chunk_delta_rule, fused_chunk_delta_rule
+from fla.utils import device
+
+
+def time_fwd(func, *args, **kwargs):
+    time_fb = benchmark_forward(func, *args, **kwargs)
+    return time_fb[1].mean
+
+
+def time_fwd_bwd(func, *args, **kwargs):
+    time_fb = benchmark_combined(func, *args, **kwargs)
+    return time_fb[1].mean
+
+
+def time_bwd(func, *args, **kwargs):
+    time_fb = benchmark_backward(func, *args, **kwargs)
+    return time_fb[1].mean
+
+
+repeats = 256
+dtype = torch.bfloat16
+
+
+bs_seqlen_vals = [(8, 2048), (4, 4096), (2, 8192)]
+causal_vals = [True]
+headdim_vals = [64, 128, 256]
+dim = 2048
+dropout_p = 0.0
+
+
+methods = (["chunk_delta_rule", "fused_chunk_delta_rule"])
+time_f = {}
+time_b = {}
+time_f_b = {}
+speed_f = {}
+speed_b = {}
+speed_f_b = {}
+for causal in causal_vals:
+    for headdim in headdim_vals:
+        for B, seqlen in bs_seqlen_vals:
+            config = (causal, headdim, B, seqlen)
+            H = dim // headdim
+            q = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            k = F.normalize(torch.randn(B, H, seqlen, headdim, device=device, dtype=dtype), p=2, dim=-1).requires_grad_(True)
+            v = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            beta = torch.rand(B, H, seqlen, device=device, dtype=dtype).sigmoid().requires_grad_(True)
+            o1, _ = chunk_delta_rule(q, k, v, beta)
+            o1.sum().backward(retain_graph=True)
+            f_b = time_fwd_bwd(
+                chunk_delta_rule, q, k, v, beta, verbose=False
+            )
+            time_f_b[config, "chunk_delta_rule"] = f_b
+
+            # q = torch.randn(B, seqlen, H, headdim, device=device, requires_grad=True, dtype=dtype)
+            # k = torch.randn(B, seqlen, H, headdim, device=device, requires_grad=True, dtype=dtype)
+            # v = torch.randn(B, seqlen, H, headdim, device=device, requires_grad=True, dtype=dtype)
+            f_b = time_fwd_bwd(
+                fused_chunk_delta_rule, q, k, v, beta, verbose=False
+            )
+            time_f_b[config, "fused_chunk_delta_rule"] = f_b
+
+            print(f"### causal={causal}, headdim={headdim}, B={B}, seqlen={seqlen} ###")
+            for method in methods:
+                # time_f_b[config, method] = time_f[config, method] + time_b[config, method]
+                print(f"{method:>50} fwd + bwd:\t {time_f_b[config, method]*1000:>6.4f} ms ")
+
+                # speed_f[config, method] = efficiency(
+                #     flops(B, seqlen, headdim, H, causal, mode="fwd"),
+                #     time_f[config, method]
+                # )
+                # speed_b[config, method] = efficiency(
+                #     flops(B, seqlen, headdim, H, causal, mode="bwd"),
+                #     time_b[config, method]
+                # )
+                # speed_f_b[config, method] = efficiency(
+                #     flops(B, seqlen, headdim, H, causal, mode="fwd_bwd"),
+                #     time_f_b[config, method]
+                # )
+                # print(
+                #     f"{method} fwd: {speed_f[config, method]:.2f} TFLOPs/s, "
+                #     f"bwd: {speed_b[config, method]:.2f} TFLOPs/s, "
+                #     f"fwd + bwd: {speed_f_b[config, method]:.2f} TFLOPs/s"
+                # )
+
+
+# with open('flash2_attn_time.plk', 'wb') as fp:
+#     pickle.dump((speed_f, speed_b, speed_f_b), fp, protocol=pickle.HIGHEST_PROTOCOL)

upstream/flash-linear-attention/benchmarks/ops/benchmark_fla.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+
+import torch
+import triton
+
+from fla.ops.based import parallel_based
+from fla.ops.gla import fused_chunk_gla
+from fla.ops.retention import fused_chunk_retention, parallel_retention
+
+try:
+    from flash_attn import flash_attn_func
+    HAS_FLASH = True
+except ImportError:
+    HAS_FLASH = False
+
+
+@triton.testing.perf_report(
+    triton.testing.Benchmark(
+        # argument names to use as an x-axis for the plot
+        x_names=['T'],
+        # different possible values for `x_name`
+        x_vals=[128 * 2 ** i for i in range(0, 8)],
+        # argument name whose value corresponds to a different line in the plot
+        line_arg='provider',
+        # possible values for `line_arg``
+        line_vals=['retention_parallel', 'retention_fused_chunk',
+                   'gla_fused_chunk', 'based_parallel'] + (['flash'] if HAS_FLASH else []),
+        # label name for the lines
+        line_names=['retention_parallel_fwdbwd', 'retention_fused_chunk_fwdbwd',
+                    'gla_fused_chunk_fwdbwd', 'based_parallel_fwdbwd'] + (['flash_fwdbwd'] if HAS_FLASH else []),
+        # line styles
+        styles=[('green', '-'), ('blue', '--'), ('red', '-.'), ('cyan', ':')] + \
+        ([('yellow', 'dotted')] if HAS_FLASH else []),
+        ylabel="Execution Time (ms)",  # label name for the y-axis
+        # name for the plot. Used also as a file name for saving the plot.
+        plot_name="Performance",
+        args={},
+    )
+)
+def benchmark(T, provider):
+    from fla.utils import device
+    dtype = torch.bfloat16
+    requires_grad = True
+    B, H, D = 16, 8, 128
+
+    if provider == 'flash':
+        q = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        k = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        v = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    elif "based" in provider:
+        q = torch.randn(B, H, T, 16, device=device, requires_grad=requires_grad, dtype=dtype)
+        k = torch.randn(B, H, T, 16, device=device, requires_grad=requires_grad, dtype=dtype)
+        v = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    elif "gla" in provider:
+        q = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        k = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        v = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        g = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    else:
+        q = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        k = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        v = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+
+    do = torch.rand_like(v, dtype=dtype)
+
+    quantiles = [0.5, 0.2, 0.8]
+    results = 0, 0, 0
+    if provider == 'flash':
+        results = triton.testing.do_bench(lambda: flash_attn_func(q, k, v).backward(do), quantiles=quantiles)
+    elif provider == 'retention_parallel':
+        results = triton.testing.do_bench(lambda: parallel_retention(q, k, v).backward(do), quantiles=quantiles)
+    elif provider == 'retention_fused_chunk':
+        results = triton.testing.do_bench(lambda: fused_chunk_retention(q, k, v).backward(do), quantiles=quantiles)
+    elif provider == 'based_parallel':
+        results = triton.testing.do_bench(lambda: parallel_based(q, k, v).backward(do), quantiles=quantiles)
+    elif provider == 'gla_fused_chunk':
+        results = triton.testing.do_bench(lambda: fused_chunk_gla(q, k, v, g).backward(do), quantiles=quantiles)
+
+    return results
+
+
+if __name__ == '__main__':
+    benchmark.run(print_data=True, show_plots=True)

upstream/flash-linear-attention/benchmarks/ops/benchmark_gla.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+
+import torch
+import triton
+from torch.nn import functional as F
+
+from fla.ops.gla import chunk_gla, fused_chunk_gla, fused_recurrent_gla
+from fla.ops.retention import chunk_retention, parallel_retention
+from fla.ops.retention.naive import naive_retention
+
+
+@triton.testing.perf_report(
+    triton.testing.Benchmark(
+        # argument names to use as an x-axis for the plot
+        x_names=['T'],
+        # different possible values for `x_name`
+        x_vals=[128 * 2 ** i for i in range(0, 8)],
+        # argument name whose value corresponds to a different line in the plot
+        line_arg='provider',
+        # possible values for `line_arg``
+        line_vals=['fused_chunk_gla', 'recurrent_gla',  'chunk_gla', 'chunk_retention',
+                   'fused_chunk_gla_bwd',  'recurrent_gla_bwd', 'chunk_gla_bwd', 'chunk_retention_bwd'],
+        # label name for the lines
+        line_names=['fused_chunk_gla', 'recurrent_gla',  'chunk_gla',  'chunk_retention',
+                    'fused_chunk_gla_bwd', 'recurrent_gla_bwd', 'chunk_gla_bwd',  'chunk_retention_bwd'],
+        # line styles
+        styles=[('green', '-'), ('blue', '--'), ('red', '-.'),
+                ('cyan', ':'), ('yellow', 'dotted'), ('cyan', '--'), ('cyan', '-'), ('black', ':')],
+        ylabel="Execution Time (ms)",  # label name for the y-axis
+        # name for the plot. Used also as a file name for saving the plot.
+        plot_name="Performance",
+        args={},
+    )
+)
+def benchmark(T, provider):
+    from fla.utils import device
+    dtype = torch.bfloat16
+    requires_grad = True
+    B, H, D = 16, 8, 128
+
+    q = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    k = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    g = F.logsigmoid(torch.randn(B, H, T, D, device=device, dtype=dtype)).clamp_min(-5).requires_grad_(requires_grad)
+    v = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+
+    do = torch.ones_like(q, dtype=dtype)
+
+    quantiles = [0.5, 0.2, 0.8]
+    results = 0, 0, 0
+    if provider == 'torch':
+        if T > 2048:
+            return results
+        results = triton.testing.do_bench(lambda: naive_retention(q, k, v), quantiles=quantiles)
+    elif provider == 'recurrent_gla':
+        results = triton.testing.do_bench(lambda: fused_recurrent_gla(q, k, v, g), quantiles=quantiles)
+    elif provider == 'fused_chunk_gla':
+        results = triton.testing.do_bench(lambda: fused_chunk_gla(q, k, v, g), quantiles=quantiles)
+    elif provider == 'chunk_retention':
+        results = triton.testing.do_bench(lambda: chunk_retention(q, k, v), quantiles=quantiles)
+    elif provider == 'chunk_gla':
+        results = triton.testing.do_bench(lambda: chunk_gla(q, k, v, g), quantiles=quantiles)
+    elif provider == 'parallel':
+        results = triton.testing.do_bench(lambda: parallel_retention(q, k, v), quantiles=quantiles)
+    elif provider == 'torch_bwd':
+        if T > 2048:
+            return results
+    elif provider == 'chunk_retention_bwd':
+        results = triton.testing.do_bench(lambda: chunk_retention(q, k, v)[0].backward(do), quantiles=quantiles)
+    elif provider == 'recurrent_gla_bwd':
+        results = triton.testing.do_bench(lambda: fused_recurrent_gla(q, k, v, g)[0].backward(do), quantiles=quantiles)
+    elif provider == 'fused_chunk_gla_bwd':
+        results = triton.testing.do_bench(lambda: fused_chunk_gla(q, k, v, g)[0].backward(do), quantiles=quantiles)
+    elif provider == 'chunk_gla_bwd':
+        results = triton.testing.do_bench(lambda: chunk_gla(q, k, v, g)[0].backward(do), quantiles=quantiles)
+    elif provider == 'parallel_bwd':
+        results = triton.testing.do_bench(lambda: parallel_retention(q, k, v)[0].backward(do), quantiles=quantiles)
+    return results
+
+
+if __name__ == '__main__':
+    benchmark.run(print_data=True)

upstream/flash-linear-attention/benchmarks/ops/benchmark_gsa.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+
+import torch
+import triton
+from torch.nn import functional as F
+
+from fla.ops.gla import chunk_gla
+from fla.ops.gsa import chunk_gsa, fused_recurrent_gsa
+from fla.ops.retention import chunk_retention
+
+try:
+    from flash_attn import flash_attn_func
+    HAS_FLASH = True
+except BaseException:
+    HAS_FLASH = False
+
+
+@triton.testing.perf_report(
+    triton.testing.Benchmark(
+        # argument names to use as an x-axis for the plot
+        x_names=['T'],
+        # different possible values for `x_name`
+        x_vals=[128 * 2 ** i for i in range(0, 8)],
+        # argument name whose value corresponds to a different line in the plot
+        line_arg='provider',
+        # possible values for `line_arg``
+        line_vals=['gsa_recurrent', 'gsa_chunk', 'gla',
+                   'gsa_recurrent_bwd', 'gsa_chunk_bwd', 'gla_bwd', 'retention_bwd', 'flash_bwd'],
+        # label name for the lines
+        line_names=['gsa_recurrent', 'gsa_chunk', 'gla',
+                    'gsa_recurrent_bwd', 'gsa_chunk_bwd', 'gla_bwd', 'retention_bwd', 'flash_bwd'],
+        # line styles
+        styles=[('green', '-'), ('blue', '--'), ('red', '-.'),
+                ('cyan', ':'), ('yellow', 'dotted'), ('black', ':'), ('green', ':'), ('green', 'dotted'), ('green', ':')],
+        ylabel="Execution Time (ms)",  # label name for the y-axis
+        # name for the plot. Used also as a file name for saving the plot.
+        plot_name="Performance",
+        args={},
+    )
+)
+def benchmark(T, provider):
+    from fla.utils import device
+    dtype = torch.bfloat16
+    requires_grad = True
+    B, H, D, M = 16, 4, 128, 64
+
+    q = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    k = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    v = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    if provider.startswith('gsa'):
+        f = F.logsigmoid(torch.randn(B, H, T, M, device=device, dtype=dtype))
+        s = (1 - f.exp()).to(f.dtype)
+    if provider.startswith('gla'):
+        g = F.logsigmoid(torch.randn(B, H, T, D, device=device, dtype=dtype))
+        g = g.clamp_min(-5).requires_grad_(requires_grad)
+    if provider.startswith('flash'):
+        q = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        k = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        v = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    do = torch.ones_like(v, dtype=dtype)
+
+    quantiles = [0.5, 0.2, 0.8]
+    if provider == 'gsa_recurrent':
+        return triton.testing.do_bench(lambda: fused_recurrent_gsa(q, k, v, s, f), quantiles=quantiles)
+    if provider == 'gsa_chunk':
+        return triton.testing.do_bench(lambda: chunk_gsa(q, k, v, s, f), quantiles=quantiles)
+    elif provider == 'gla':
+        return triton.testing.do_bench(lambda: chunk_gla(q, k, v, g), quantiles=quantiles)
+    elif provider == 'gsa_recurrent_bwd':
+        return triton.testing.do_bench(lambda: fused_recurrent_gsa(q, k, v, s, f)[0].backward(do), quantiles=quantiles)
+    elif provider == 'gsa_chunk_bwd':
+        return triton.testing.do_bench(lambda: chunk_gsa(q, k, v, s, f)[0].backward(do), quantiles=quantiles)
+    elif provider == 'gla_bwd':
+        return triton.testing.do_bench(lambda: chunk_gla(q, k, v, g)[0].backward(do), quantiles=quantiles)
+    elif provider == 'retention_bwd':
+        return triton.testing.do_bench(lambda: chunk_retention(q, k, v)[0].backward(do), quantiles=quantiles)
+    elif provider == 'flash_bwd':
+        return triton.testing.do_bench(lambda: flash_attn_func(q, k, v, causal=True).backward(do), quantiles=quantiles)
+
+
+if __name__ == '__main__':
+    benchmark.run(print_data=True)

upstream/flash-linear-attention/benchmarks/ops/benchmark_hgrn.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+
+import torch
+import triton
+
+from fla.ops.hgrn import chunk_hgrn, fused_recurrent_hgrn
+
+
+@triton.testing.perf_report(
+    triton.testing.Benchmark(
+        # argument names to use as an x-axis for the plot
+        x_names=['T'],
+        # different possible values for `x_name`
+        x_vals=[128 * 2 ** i for i in range(0, 8)],
+        # argument name whose value corresponds to a different line in the plot
+        line_arg='provider',
+        # possible values for `line_arg``
+        line_vals=['chunk', 'recurrent', 'chunk_bwd', 'recurrent_bwd'],
+        # label name for the lines
+        line_names=['chunk', 'recurrent', 'chunk_bwd', 'recurrent_bwd'],
+        # line styles
+        styles=[('green', '-'), ('blue', '--'), ('red', '-.'), ('cyan', ':'), ('yellow', 'dotted'), ('black', 'dashed')],
+        ylabel="Execution Time (ms)",  # label name for the y-axis
+        # name for the plot. Used also as a file name for saving the plot.
+        plot_name="Performance",
+        args={},
+    )
+)
+def benchmark(T, provider):
+    from fla.utils import device
+    dtype = torch.bfloat16
+    B, D = 16, 512
+
+    x = torch.randn((B, T, D), dtype=dtype, device=device)
+    g = torch.randn((B, T, D), dtype=dtype, device=device).sigmoid()
+    x = (1 - g) * x
+    x, g = (i.detach().clone().to(dtype).requires_grad_() for i in (x, g))
+    do = torch.randn_like(x, dtype=dtype)
+    quantiles = [0.5, 0.2, 0.8]
+    results = 0, 0, 0
+    if provider == 'chunk':
+        results = triton.testing.do_bench(lambda: chunk_hgrn(x, g), quantiles=quantiles)
+    if provider == 'recurrent':
+        results = triton.testing.do_bench(lambda: fused_recurrent_hgrn(x, g), quantiles=quantiles)
+    if provider == 'chunk_bwd':
+        results = triton.testing.do_bench(lambda: chunk_hgrn(x, g)[0].backward(do), quantiles=quantiles)
+    if provider == 'recurrent_bwd':
+        results = triton.testing.do_bench(lambda: fused_recurrent_hgrn(x, g)[0].backward(do), quantiles=quantiles)
+    return results
+
+
+if __name__ == '__main__':
+    benchmark.run(print_data=True)

upstream/flash-linear-attention/benchmarks/ops/benchmark_nsa.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+
+import torch
+import triton
+from flash_attn import flash_attn_func
+
+from fla.ops.nsa import parallel_nsa
+
+
+@triton.testing.perf_report(
+    triton.testing.Benchmark(
+        # argument names to use as an x-axis for the plot
+        x_names=['T'],
+        # different possible values for `x_name`
+        x_vals=[128 * 2 ** i for i in range(0, 8)],
+        # argument name whose value corresponds to a different line in the plot
+        line_arg='provider',
+        # possible values for `line_arg``
+        line_vals=['nsa', 'nsa_bwd', 'flash', 'flash_bwd'],
+        # label name for the lines
+        line_names=['nsa', 'nsa_bwd', 'flash', 'flash_bwd'],
+        # line styles
+        styles=[('green', '-'), ('blue', '-'), ('red', '-'), ('green', 'dotted'),
+                ('blue', 'dotted'), ('red', 'dotted'), ('cyan', '-'), ('cyan', 'dotted')],
+        ylabel="Execution Time (ms)",  # label name for the y-axis
+        # name for the plot. Used also as a file name for saving the plot.
+        plot_name="Performance",
+        args={},
+    )
+)
+def benchmark(T, provider):
+    from fla.utils import device
+    dtype = torch.bfloat16
+    requires_grad = True
+    B, H, HQ, D, S = 4, 4, 64, 128, 16
+    block_size = 64
+
+    q = torch.randn(B, T, HQ, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    k = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    v = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    do = torch.ones_like(q, dtype=dtype)
+
+    indices = torch.full((B, T, H, S), T, dtype=torch.long, device=device)
+    for b in range(B):
+        for t in range(T):
+            for h in range(H):
+                i_i = torch.randperm(max(1, triton.cdiv(t, block_size)))[:S]
+                indices[b, t, h, :len(i_i)] = i_i
+    indices = indices.sort(-1)[0]
+
+    quantiles = [0.5, 0.2, 0.8]
+    results = 0, 0, 0
+    if provider == 'nsa':
+        results = triton.testing.do_bench(
+            lambda: parallel_nsa(q, k, v, indices, block_size),
+            quantiles=quantiles
+        )
+    elif provider == 'nsa_bwd':
+        results = triton.testing.do_bench(
+            lambda: parallel_nsa(q, k, v, indices, block_size).backward(do),
+            quantiles=quantiles
+        )
+    elif provider == 'flash':
+        results = triton.testing.do_bench(
+            lambda: flash_attn_func(q, k, v, causal=True),
+            quantiles=quantiles
+        )
+    elif provider == 'flash_bwd':
+        results = triton.testing.do_bench(
+            lambda: flash_attn_func(q, k, v, causal=True).backward(do),
+            quantiles=quantiles
+        )
+    return results
+
+
+if __name__ == '__main__':
+    benchmark.run(print_data=True, save_path='.')

upstream/flash-linear-attention/benchmarks/ops/benchmark_retention.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import torch
+import triton
+from flash_attn import flash_attn_func
+
+from fla.ops.retention import chunk_retention, parallel_retention
+
+
+@triton.testing.perf_report(
+    triton.testing.Benchmark(
+        # argument names to use as an x-axis for the plot
+        x_names=['T'],
+        # different possible values for `x_name`
+        x_vals=[128 * 2 ** i for i in range(0, 8)],
+        # argument name whose value corresponds to a different line in the plot
+        line_arg='provider',
+        # possible values for `line_arg``
+        line_vals=['chunk', 'parallel', 'flash', 'chunk_bwd', 'parallel_bwd', 'flash_bwd'],
+        # label name for the lines
+        line_names=['chunk_fwd', 'parallel_fwd', 'flash_fwd', 'chunk_fwdbwd', 'parallel_fwdbwd', 'flash_fwdbwd'],
+        # line styles
+        styles=[('green', '-'), ('blue', '-'), ('red', '-'), ('green', 'dotted'), ('blue', 'dotted'), ('red', 'dotted')],
+        ylabel="Execution Time (ms)",  # label name for the y-axis
+        # name for the plot. Used also as a file name for saving the plot.
+        plot_name="Performance",
+        args={},
+    )
+)
+def benchmark(T, provider):
+    from fla.utils import device
+    dtype = torch.bfloat16
+    requires_grad = True
+    B, H, D = 4, 8, 256
+    os.environ['CUDA_LAUNCH_BLOCKING'] = '1'
+
+    if provider == 'flash' or provider == 'flash_bwd':
+        q = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        k = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        v = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    else:
+        q = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        k = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        v = torch.randn(B, H, T, D, device=device, requires_grad=requires_grad, dtype=dtype)
+    do = torch.ones_like(q, dtype=dtype)
+
+    quantiles = [0.5, 0.2, 0.8]
+    results = 0, 0, 0
+    if provider == 'chunk':
+        results = triton.testing.do_bench(lambda: chunk_retention(q, k, v), quantiles=quantiles)
+    elif provider == 'parallel':
+        results = triton.testing.do_bench(lambda: parallel_retention(q, k, v), quantiles=quantiles)
+    elif provider == 'flash':
+        results = triton.testing.do_bench(lambda: flash_attn_func(q, k, v, causal=True), quantiles=quantiles)
+    elif provider == 'chunk_bwd':
+        results = triton.testing.do_bench(lambda: chunk_retention(q, k, v)[0].backward(do), quantiles=quantiles)
+    elif provider == 'parallel_bwd':
+        results = triton.testing.do_bench(lambda: parallel_retention(q, k, v)[0].backward(do), quantiles=quantiles)
+    elif provider == 'flash_bwd':
+        results = triton.testing.do_bench(lambda: flash_attn_func(q, k, v, causal=True).backward(do), quantiles=quantiles)
+    return results
+
+
+if __name__ == '__main__':
+    benchmark.run(print_data=True, save_path='.')

upstream/flash-linear-attention/benchmarks/ops/benchmark_rwkv.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import torch
+import triton
+from torch.nn import functional as F
+
+from fla.ops.gla import chunk_gla
+from fla.ops.retention import chunk_retention
+from fla.ops.rwkv6 import chunk_rwkv6
+from fla.ops.rwkv7 import chunk_rwkv7
+
+try:
+    from flash_attn import flash_attn_func
+    HAS_FLASH = True
+except BaseException:
+    HAS_FLASH = False
+
+
+@triton.testing.perf_report(
+    triton.testing.Benchmark(
+        # argument names to use as an x-axis for the plot
+        x_names=['T'],
+        # different possible values for `x_name`
+        x_vals=[128 * 2 ** i for i in range(0, 8)],
+        # argument name whose value corresponds to a different line in the plot
+        line_arg='provider',
+        # possible values for `line_arg``
+        # line styles
+        line_vals=['rwkv6', 'rwkv7', 'gla', 'flash', 'rwkv6_bwd', 'rwkv7_bwd', 'gla_bwd', 'retention_bwd', 'flash_bwd'],
+        # label name for the lines
+        line_names=['rwkv6', 'rwkv7', 'gla', 'flash', 'rwkv6_bwd', 'rwkv7_bwd', 'gla_bwd', 'retention_bwd', 'flash_bwd'],
+        # # line styles
+        styles=[
+            ('green', '-'),      # rwkv6
+            ('blue', '--'),      # rwkv7
+            ('red', '-.'),       # gla
+            ('cyan', ':'),       # rwkv6_bwd
+            ('magenta', '-'),    # rwkv7_bwd
+            ('yellow', 'dotted'),  # gla_bwd
+            ('black', ':'),      # retention_bwd
+            ('gray', ':'),       # flash
+            ('gray', '--')       # flash_bwd
+        ],
+        ylabel="Execution Time (ms)",  # label name for the y-axis
+        # name for the plot. Used also as a file name for saving the plot.
+        plot_name="Performance",
+        args={},
+    )
+)
+def benchmark(T, provider):
+    from fla.utils import device
+    dtype = torch.bfloat16
+    requires_grad = True
+    # Read B, H, D from environment variables, default to 16, 8, 128 if not set
+    B = int(os.getenv('BENCH_B', '8'))  # Batch size
+    H = int(os.getenv('BENCH_H', '64'))   # Number of heads
+    D = int(os.getenv('BENCH_D', '64'))  # Dimension per head
+    with torch.no_grad():
+        q = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        k = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        v = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        if provider.startswith('flash'):
+            q = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+            k = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+            v = torch.randn(B, T, H, D, device=device, requires_grad=requires_grad, dtype=dtype)
+        if provider.startswith('gla'):
+            g = F.logsigmoid(torch.randn(B, T, H, D, device=device, dtype=dtype))
+            g = g.clamp_min(-5).requires_grad_(requires_grad)
+        if provider.startswith('rwkv6'):
+            w = F.logsigmoid(torch.randn(B, T, H, D, device=device, dtype=dtype)).requires_grad_(True)
+            u = torch.randn(H, D, device=device, dtype=dtype).requires_grad_(True)
+        if provider.startswith('rwkv7'):
+            q = torch.empty(B, T, H, D, device=device).uniform_(-1, 1).to(dtype=dtype).requires_grad_(True)
+            k = torch.empty(B, T, H, D, device=device).uniform_(-1, 1).to(dtype=dtype).requires_grad_(True)
+            v = torch.empty(B, T, H, D, device=device).uniform_(-1, 1).to(dtype=dtype).requires_grad_(True)
+            w = F.logsigmoid(torch.randn(B, T, H, D, device=device, dtype=dtype)).requires_grad_(True)
+            kk = torch.empty(B, T, H, D, device=device).uniform_(-1, 1)
+            kk = torch.nn.functional.normalize(kk, dim=-1).to(dtype=dtype)
+
+            a = -kk.clone().requires_grad_(True)  # -kk
+            a_scale = torch.empty(B, T, H, D, device=device).uniform_(0, 0.1).to(dtype=dtype)
+            b = (kk * a_scale).requires_grad_(True)  # kk*a
+
+    do = torch.ones_like(v, dtype=dtype)
+
+    quantiles = [0.5, 0.2, 0.8]
+    if provider == 'rwkv6':
+        results = triton.testing.do_bench(lambda: chunk_rwkv6(q, k, v, w, u), quantiles=quantiles)
+    elif provider == 'rwkv7':
+        results = triton.testing.do_bench(lambda: chunk_rwkv7(q, w, k, v, a, b), quantiles=quantiles)
+    elif provider == 'gla':
+        results = triton.testing.do_bench(lambda: chunk_gla(q, k, v, g), quantiles=quantiles)
+    elif provider == 'rwkv6_bwd':
+        results = triton.testing.do_bench(lambda: chunk_rwkv6(q, k, v, w, u)[0].backward(do), quantiles=quantiles)
+    elif provider == 'rwkv7_bwd':
+        results = triton.testing.do_bench(lambda: chunk_rwkv7(q, w, k, v, a, b)[0].backward(do), quantiles=quantiles)
+    elif provider == 'gla_bwd':
+        results = triton.testing.do_bench(lambda: chunk_gla(q, k, v, g)[0].backward(do), quantiles=quantiles)
+    elif provider == 'retention_bwd':
+        results = triton.testing.do_bench(lambda: chunk_retention(q, k, v)[0].backward(do), quantiles=quantiles)
+    elif provider == 'flash':
+        results = triton.testing.do_bench(lambda: flash_attn_func(q, k, v, causal=True), quantiles=quantiles)
+    elif provider == 'flash_bwd':
+        results = triton.testing.do_bench(lambda: flash_attn_func(q, k, v, causal=True).backward(do), quantiles=quantiles)
+    return results
+
+
+if __name__ == '__main__':
+    benchmark.run(print_data=True)

upstream/flash-linear-attention/benchmarks/ops/benchmark_titans.py

@@ -0,0 +1,138 @@
+# Install the newest triton version with
+# pip install "git+https://github.com/openai/triton.git#egg=triton&subdirectory=python"
+
+import torch
+from benchmark import benchmark_backward, benchmark_combined, benchmark_forward
+from torch.nn import functional as F
+
+from fla.ops.titans.naive import chunk_titans_linear_ref
+
+# from flash_attn import flash_attn_func
+
+
+def time_fwd(func, *args, **kwargs):
+    time_fb = benchmark_forward(func, *args, **kwargs)
+    return time_fb[1].mean
+
+
+def time_fwd_bwd(func, *args, **kwargs):
+    time_fb = benchmark_combined(func, *args, **kwargs)
+    return time_fb[1].mean
+
+
+def time_bwd(func, *args, **kwargs):
+    time_fb = benchmark_backward(func, *args, **kwargs)
+    return time_fb[1].mean
+
+
+repeats = 256
+device = "cuda"
+dtype = torch.bfloat16
+
+bs_seqlen_vals = [(2, 1024), (2, 2048)]
+causal_vals = [True]
+headdim_vals = [4, 8]
+dim = 16
+dropout_p = 0.0
+
+methods = ["naive_titans", "chunk_titans"]
+time_f = {}
+time_b = {}
+time_f_b = {}
+speed_f = {}
+speed_b = {}
+speed_f_b = {}
+for causal in causal_vals:
+    for headdim in headdim_vals:
+        for B, seqlen in bs_seqlen_vals:
+            config = (causal, headdim, B, seqlen)
+            H = dim // headdim
+
+            q = torch.randn(
+                B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype
+            )
+            k = F.normalize(
+                torch.randn(B, H, seqlen, headdim, device=device, dtype=dtype),
+                p=2,
+                dim=-1,
+            ).requires_grad_(True)
+            v = torch.randn(
+                B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype
+            )
+            w = torch.randn(H, headdim, device=device, requires_grad=True, dtype=dtype)
+            b = torch.randn(H, headdim, device=device, requires_grad=True, dtype=dtype)
+            theta = torch.rand(
+                B, H, seqlen, 1, dtype=dtype, device=device, requires_grad=True
+            )
+            alpha = torch.rand(
+                B, H, seqlen, 1, dtype=dtype, device=device, requires_grad=True
+            )
+            eta = torch.rand(
+                B, H, seqlen, 1, dtype=dtype, device=device, requires_grad=True
+            )
+            o2, _ = chunk_titans_linear_ref(
+                q, k, v, w, b, theta, alpha, eta, chunk_size=16, use_chunk=False
+            )
+            o2.sum().backward(retain_graph=True)
+            f_b = time_fwd_bwd(
+                chunk_titans_linear_ref,
+                q,
+                k,
+                v,
+                w,
+                b,
+                theta,
+                alpha,
+                eta,
+                use_chunk=False,
+                verbose=False,
+            )
+            time_f_b[config, "naive_titans"] = f_b
+
+            o3, _ = chunk_titans_linear_ref(
+                q, k, v, w, b, theta, alpha, eta, chunk_size=16, use_chunk=True
+            )
+            o3.sum().backward(retain_graph=True)
+            f_b = time_fwd_bwd(
+                chunk_titans_linear_ref,
+                q,
+                k,
+                v,
+                w,
+                b,
+                theta,
+                alpha,
+                eta,
+                chunk_size=16,
+                use_chunk=True,
+                verbose=False,
+            )
+            time_f_b[config, "chunk_titans"] = f_b
+
+            print(f"### causal={causal}, headdim={headdim}, B={B}, seqlen={seqlen} ###")
+            for method in methods:
+                # time_f_b[config, method] = time_f[config, method] + time_b[config, method]
+                print(
+                    f"{method:>50} fwd + bwd:\t {time_f_b[config, method] * 1000:>6.4f} ms "
+                )
+
+                # speed_f[config, method] = efficiency(
+                #     flops(B, seqlen, headdim, H, causal, mode="fwd"),
+                #     time_f[config, method]
+                # )
+                # speed_b[config, method] = efficiency(
+                #     flops(B, seqlen, headdim, H, causal, mode="bwd"),
+                #     time_b[config, method]
+                # )
+                # speed_f_b[config, method] = efficiency(
+                #     flops(B, seqlen, headdim, H, causal, mode="fwd_bwd"),
+                #     time_f_b[config, method]
+                # )
+                # print(
+                #     f"{method} fwd: {speed_f[config, method]:.2f} TFLOPs/s, "
+                #     f"bwd: {speed_b[config, method]:.2f} TFLOPs/s, "
+                #     f"fwd + bwd: {speed_f_b[config, method]:.2f} TFLOPs/s"
+                # )
+
+# with open('flash2_attn_time.plk', 'wb') as fp:
+#     pickle.dump((speed_f, speed_b, speed_f_b), fp, protocol=pickle.HIGHEST_PROTOCOL)

upstream/flash-linear-attention/benchmarks/ops/benchmark_ttt.py

@@ -0,0 +1,130 @@
+# Install the newest triton version with
+# pip install "git+https://github.com/openai/triton.git#egg=triton&subdirectory=python"
+
+import torch
+from benchmark import benchmark_backward, benchmark_combined, benchmark_forward
+from torch.nn import functional as F
+
+from fla.ops.delta_rule import chunk_delta_rule
+from fla.ops.gla import chunk_gla
+from fla.ops.ttt import chunk_ttt_linear, fused_chunk_ttt_linear
+from fla.utils import device
+
+# from flash_attn import flash_attn_func
+
+
+def time_fwd(func, *args, **kwargs):
+    time_fb = benchmark_forward(func, *args, **kwargs)
+    return time_fb[1].mean
+
+
+def time_fwd_bwd(func, *args, **kwargs):
+    time_fb = benchmark_combined(func, *args, **kwargs)
+    return time_fb[1].mean
+
+
+def time_bwd(func, *args, **kwargs):
+    time_fb = benchmark_backward(func, *args, **kwargs)
+    return time_fb[1].mean
+
+
+repeats = 256
+
+
+dtype = torch.bfloat16
+
+
+bs_seqlen_vals = [(8, 2048), (4, 4096), (2, 8192)]
+causal_vals = [True]
+# headdim_vals = [64, 128]
+headdim_vals = [64,]
+dim = 2048
+dropout_p = 0.0
+
+
+methods = (["chunk_gla", "chunk_delta_rule", "chunk_ttt_linear", "fused_chunk_ttt_linear"])
+time_f = {}
+time_b = {}
+time_f_b = {}
+speed_f = {}
+speed_b = {}
+speed_f_b = {}
+for causal in causal_vals:
+    for headdim in headdim_vals:
+        for B, seqlen in bs_seqlen_vals:
+            config = (causal, headdim, B, seqlen)
+            H = dim // headdim
+            q = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            k = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            v = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            g = torch.randn(B, H, seqlen, headdim, device=device, dtype=dtype).sigmoid().requires_grad_(True) / 16
+            o1, _ = chunk_gla(q, k, v, g)
+            o1.sum().backward(retain_graph=True)
+            f_b = time_fwd_bwd(
+                chunk_gla, q, k, v, g, verbose=False
+            )
+            time_f_b[config, "chunk_gla"] = f_b
+
+            q = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            k = F.normalize(torch.randn(B, H, seqlen, headdim, device=device, dtype=dtype), p=2, dim=-1).requires_grad_(True)
+            v = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            beta = torch.rand(B, H, seqlen, device=device, dtype=dtype).sigmoid().requires_grad_(True)
+            o2, _ = chunk_delta_rule(q, k, v, beta)
+            o2.sum().backward(retain_graph=True)
+            f_b = time_fwd_bwd(
+                chunk_delta_rule, q, k, v, beta, verbose=False
+            )
+            time_f_b[config, "chunk_delta_rule"] = f_b
+
+            q = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            k = F.normalize(torch.randn(B, H, seqlen, headdim, device=device, dtype=dtype), p=2, dim=-1).requires_grad_(True)
+            v = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            w = torch.randn(H, headdim, device=device, requires_grad=True, dtype=dtype)
+            b = torch.randn(H, headdim, device=device, requires_grad=True, dtype=dtype)
+            eta = torch.rand(B, H, seqlen, 1, device=device, requires_grad=True, dtype=dtype) * 5e-3
+            o3, _, _ = chunk_ttt_linear(q, k, v, w, b, eta, chunk_size=16)
+            o3.sum().backward(retain_graph=True)
+            f_b = time_fwd_bwd(
+                chunk_ttt_linear, q, k, v, w, b, eta, chunk_size=16, verbose=False
+            )
+            time_f_b[config, "chunk_ttt_linear"] = f_b
+
+            q = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            k = F.normalize(torch.randn(B, H, seqlen, headdim, device=device, dtype=dtype), p=2, dim=-1).requires_grad_(True)
+            v = torch.randn(B, H, seqlen, headdim, device=device, requires_grad=True, dtype=dtype)
+            w = torch.randn(H, headdim, device=device, requires_grad=True, dtype=dtype)
+            b = torch.randn(H, headdim, device=device, requires_grad=True, dtype=dtype)
+            eta = torch.rand(B, H, seqlen, 1, device=device, requires_grad=True, dtype=dtype) * 5e-3
+            o4, _, _ = fused_chunk_ttt_linear(q, k, v, w, b, eta, chunk_size=16)
+            o4.sum().backward(retain_graph=True)
+            f_b = time_fwd_bwd(
+                fused_chunk_ttt_linear, q, k, v, w, b, eta, chunk_size=16, verbose=False
+            )
+            time_f_b[config, "fused_chunk_ttt_linear"] = f_b
+
+            print(f"### causal={causal}, headdim={headdim}, B={B}, seqlen={seqlen} ###")
+            for method in methods:
+                # time_f_b[config, method] = time_f[config, method] + time_b[config, method]
+                print(f"{method:>50} fwd + bwd:\t {time_f_b[config, method]*1000:>6.4f} ms ")
+
+                # speed_f[config, method] = efficiency(
+                #     flops(B, seqlen, headdim, H, causal, mode="fwd"),
+                #     time_f[config, method]
+                # )
+                # speed_b[config, method] = efficiency(
+                #     flops(B, seqlen, headdim, H, causal, mode="bwd"),
+                #     time_b[config, method]
+                # )
+                # speed_f_b[config, method] = efficiency(
+                #     flops(B, seqlen, headdim, H, causal, mode="fwd_bwd"),
+                #     time_f_b[config, method]
+                # )
+                # print(
+                #     f"{method} fwd: {speed_f[config, method]:.2f} TFLOPs/s, "
+                #     f"bwd: {speed_b[config, method]:.2f} TFLOPs/s, "
+                #     f"fwd + bwd: {speed_f_b[config, method]:.2f} TFLOPs/s"
+                # )
+
+
+# with open('flash2_attn_time.plk', 'wb') as fp:
+#     pickle.dump((speed_f, speed_b, speed_f_b), fp, protocol=pickle.HIGHEST_PROTOCOL)