mjolnir-cli 0.2.0__py3-none-any.whl

mjolnir_cli/drivers/fi_driver.py

@@ -0,0 +1,134 @@
+"""FlashInfer paged fp8 decode driver for ncu (NHD or HND KV layout).
+
+The FlashInfer leg of ``mjolnir verify``: BENCH_B sequences (default 1) of
+BENCH_L tokens, bf16 Q, fp8 e4m3 KV, tensor-core decode
+(``use_tensor_cores=True``, plan once, split-KV as FlashInfer chooses) — the
+decode path vLLM's FlashInfer backend runs. BENCH_QLEN > 1 (speculative
+verification, e.g. 4 for MTP=3) runs the paged *prefill* wrapper, causal,
+BENCH_QLEN query tokens per sequence — how stock vLLM's FlashInfer backend
+runs a multi-token verify batch. BENCH_ITERS launches, no warmup, so ncu sees exactly
+BENCH_ITERS invocations. The KV data is generated once in NHD order; the
+HND run uses the same values transposed, so NHD vs HND differ only in layout.
+
+    FI_LAYOUT=HND BENCH_L=65536 BENCH_ITERS=50 python3 fi_driver.py
+
+Env: FI_LAYOUT (NHD|HND), BENCH_L, BENCH_ITERS, BENCH_B (1), BENCH_QLEN (1), BENCH_HQ (24), BENCH_HK (4),
+     BENCH_D (256), BENCH_PAGE (128), BENCH_CONTIG=1 (pages in order; default
+     is a random page permutation, as the Mjolnir harness), FI_CHECK=1 (also
+     run the other layout once and assert the outputs match), BENCH_SEED.
+     The pre-rename FI_L / FI_ITERS / FI_HQ / FI_HK / FI_D / FI_PAGE names
+     are still honored.
+"""
+
+from __future__ import annotations
+
+import os
+
+import torch
+
+
+def env_int(name: str, default: int) -> int:
+    for k in (f"BENCH_{name}", f"FI_{name}"):
+        if k in os.environ:
+            return int(os.environ[k])
+    return default
+
+
+def main():
+    import flashinfer
+
+    layout = os.environ.get("FI_LAYOUT", "NHD").upper()
+    assert layout in ("NHD", "HND"), layout
+    L, iters = env_int("L", 8192), env_int("ITERS", 50)
+    hq, hk, d, ps = env_int("HQ", 24), env_int("HK", 4), env_int("D", 256), env_int("PAGE", 128)
+    b, qlen = env_int("B", 1), env_int("QLEN", 1)
+    check = os.environ.get("FI_CHECK", "0") == "1"
+    torch.manual_seed(env_int("SEED", 1111))
+    dev = "cuda"
+
+    pages_seq = (L + ps - 1) // ps
+    last = L - (pages_seq - 1) * ps
+    pages = b * pages_seq
+    # (pages, 2, PS, h_k, d) in fp8, filled in chunks to bound the temp size
+    nhd = torch.empty(pages, 2, ps, hk, d, dtype=torch.float8_e4m3fn, device=dev)
+    step = max(1, (64 << 20) // (2 * ps * hk * d))
+    for p0 in range(0, pages, step):
+        p1 = min(pages, p0 + step)
+        nhd[p0:p1] = (torch.randn(p1 - p0, 2, ps, hk, d, device=dev, dtype=torch.bfloat16) * 0.5).to(
+            torch.float8_e4m3fn
+        )
+    caches = {"NHD": None, "HND": None}
+
+    def cache(lay):
+        if caches[lay] is None:
+            caches[lay] = nhd if lay == "NHD" else nhd.transpose(2, 3).contiguous()
+        return caches[lay]
+
+    if os.environ.get("BENCH_CONTIG", os.environ.get("FI_CONTIG", "0")) == "1":
+        indices = torch.arange(pages, dtype=torch.int32, device=dev)
+    else:
+        indices = torch.randperm(pages, device=dev).to(torch.int32)
+    indptr = torch.arange(b + 1, dtype=torch.int32, device=dev) * pages_seq
+    last_len = torch.full((b,), last, dtype=torch.int32, device=dev)
+    q = torch.randn(b * qlen, hq, d, device=dev, dtype=torch.bfloat16)
+
+    def make(lay):
+        ws = torch.empty(256 << 20, dtype=torch.uint8, device=dev)
+        if qlen > 1:
+            w = flashinfer.BatchPrefillWithPagedKVCacheWrapper(ws, kv_layout=lay)
+            qo_indptr = torch.arange(b + 1, dtype=torch.int32, device=dev) * qlen
+            w.plan(
+                qo_indptr,
+                indptr,
+                indices,
+                last_len,
+                hq,
+                hk,
+                d,
+                ps,
+                causal=True,
+                q_data_type=torch.bfloat16,
+                kv_data_type=torch.float8_e4m3fn,
+            )
+            return w
+        w = flashinfer.BatchDecodeWithPagedKVCacheWrapper(ws, kv_layout=lay, use_tensor_cores=True)
+        kw = dict(pos_encoding_mode="NONE", q_data_type=torch.bfloat16, kv_data_type=torch.float8_e4m3fn)
+        try:
+            w.plan(indptr, indices, last_len, hq, hk, d, ps, **kw)
+        except TypeError:  # older FlashInfer: data_type instead of kv_data_type
+            kw["data_type"] = kw.pop("kv_data_type")
+            w.plan(indptr, indices, last_len, hq, hk, d, ps, **kw)
+        return w
+
+    def run(w, lay):
+        return w.run(q, cache(lay), k_scale=1.0, v_scale=1.0)
+
+    w = make(layout)
+    kv = cache(layout)
+    torch.cuda.synchronize()
+    print(
+        f"FI {layout}: b={b} q_len={qlen} L={L} pages={pages}x{ps} h_q={hq} h_k={hk} d={d} "
+        f"cache {tuple(kv.shape)} stride {kv.stride()} iters={iters}",
+        flush=True,
+    )
+
+    ev0, ev1 = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+    ev0.record()
+    out = None
+    for _ in range(iters):
+        out = run(w, layout)
+    ev1.record()
+    torch.cuda.synchronize()
+    print(f"FI {layout}: mean {ev0.elapsed_time(ev1) * 1e3 / max(1, iters):.1f} us/iter (not ncu)", flush=True)
+
+    if check:
+        other = "HND" if layout == "NHD" else "NHD"
+        ref = run(make(other), other)
+        err = (out.float() - ref.float()).abs().max().item()
+        print(f"FI check {layout} vs {other}: max abs diff {err:.3e}")
+        assert err < 1e-2, "NHD and HND outputs differ"
+    print("DONE")
+
+
+if __name__ == "__main__":
+    main()

mjolnir_cli/e2e.py

@@ -0,0 +1,302 @@
+"""End to end: the official vLLM image vs the Mjolnir image, from history.
+
+Everything here reads ``benchmarks/history.jsonl`` (written by ``mjolnir bench
+perf|ab|e2e``) — the comparison table, the README section and the opening
+infographic all come from the same pair of records:
+
+* **official** — the latest run on the upstream image (``vllm/vllm-openai:…``)
+  with a stock config: native vLLM, native FlashInfer;
+* **mjolnir**  — the latest run of the Mjolnir backend config
+  (``NVFP4_MJOLNIR``) on a Mjolnir image.
+
+Stock backends (FlashInfer, FA2) measured *on the Mjolnir image* are never
+used: that image patches FlashInfer paths too, so it is not native vLLM.
+
+Metrics (per context × concurrency cell, mean over every measured run):
+
+| key       | what                                   | better |
+|-----------|----------------------------------------|--------|
+| ``tg_tps``  | decode throughput, tokens/s (all requests) | higher |
+| ``pp_tps``  | prefill throughput, prompt tokens/s        | higher |
+| ``ttft_ms`` | time to first token, ms (e2e; falls back to llama-benchy's ``ttfr``) | lower |
+| ``itl_ms``  | inter-token latency, ms = 1000 / per-request decode rate | lower |
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from mjolnir_cli.config import BASELINE_QUANT, DEFAULT_QUANT, IMAGE_REPO
+from mjolnir_cli.history import load_records
+
+# Older images of this project (kept so history rows still classify).
+_MJOLNIR_IMAGE_PREFIXES = (IMAGE_REPO, "narandill/mjolnir-", "mjolnir/vllm-thor")
+
+
+@dataclass(frozen=True)
+class Metric:
+    key: str
+    label: str
+    unit: str
+    higher_better: bool
+    fmt: str
+
+
+METRICS: tuple[Metric, ...] = (
+    Metric("tg_tps", "decode", "t/s", True, "{:.1f}"),
+    Metric("pp_tps", "prefill", "t/s", True, "{:,.0f}"),
+    Metric("ttft_ms", "TTFT", "ms", False, "{:,.0f}"),
+    Metric("itl_ms", "ITL", "ms", False, "{:.1f}"),
+)
+BY_KEY = {m.key: m for m in METRICS}
+
+# End-to-end numbers are wall-clock serving runs (two separate server launches,
+# llama-benchy means over runs). The band that colors a gain: ±3%, the same as
+# the kernel's same-run ncu band (verify.stages.NOISE_PCT). Caveat: with MTP
+# speculative decoding the per-run decode t/s spreads ~10-15% (the acceptance
+# rate varies by prompt), so a decode mean of 6 runs carries a ~2-6% standard
+# error — a decode gain inside ~6% needs repeated sweeps (--repeat) to trust.
+E2E_NOISE_PCT = 3.0
+# the official-vs-Mjolnir comparison (README table, e2e charts, infographic)
+# and `bench e2e`'s default depths stop here: the 64K / 128K cells take hours
+# per leg; `bench perf|ab --depths` still measure beyond it
+MAX_CTX = 32768
+
+
+def is_official(rec: dict) -> bool:
+    return str(rec.get("image", "")).startswith("vllm/vllm-openai")
+
+
+def is_mjolnir(rec: dict) -> bool:
+    return str(rec.get("image", "")).startswith(_MJOLNIR_IMAGE_PREFIXES)
+
+
+def _merge(recs: list[dict]) -> dict | None:
+    """One side's records → the newest record, with every (concurrency,
+    context) cell taken from the newest run that measured it. A run at extra
+    depths (``bench e2e --depths 65536,131072``) adds cells instead of
+    replacing the table; runs with a different speculative setup than the
+    newest one are left out. ``merged_runs`` lists the raw dirs used."""
+    if not recs:
+        return None
+    recs = sorted(recs, key=lambda r: r.get("epoch", 0), reverse=True)
+    head = recs[0]
+    sp = spec_of(head)
+    cells: dict = {}
+    used: list[str] = []
+    for r in recs:
+        if spec_of(r) != sp:
+            continue
+        took = False
+        for c in r.get("cells", []):
+            k = (c.get("concurrency"), c.get("context") or 0, bool(c.get("prefill_phase")))
+            if k not in cells:
+                cells[k] = c
+                took = True
+        if took:
+            used.append(str(r.get("raw", "")))
+    out = dict(head)
+    out["cells"] = sorted(cells.values(), key=lambda c: (c.get("concurrency") or 0, c.get("context") or 0))
+    out["merged_runs"] = used
+    return out
+
+
+def latest_pair(
+    history_file: Path, mjolnir_config: str | None = None, official_config: str | None = None
+) -> tuple[dict | None, dict | None]:
+    """(official, mjolnir): each side's runs merged cell by cell, newest run
+    first (:func:`_merge`) — a stock config on the official image, and the
+    Mjolnir backend config (default ``DEFAULT_QUANT``) on a Mjolnir image.
+
+    The official side is ``official_config`` (default ``BASELINE_QUANT``,
+    native FlashInfer) when the history has it, else the newest official
+    config — so an optional official leg (``bench e2e --optional``: DSpark,
+    DFlash2 on stock vLLM) never replaces the baseline by being newer."""
+    want = mjolnir_config or DEFAULT_QUANT
+    base = official_config or BASELINE_QUANT
+    offs, mjs = [], []
+    for r in load_records(history_file):
+        if not r.get("cells"):
+            continue
+        if is_official(r) and r.get("config") != want:
+            offs.append(r)
+        elif is_mjolnir(r) and r.get("config") == want:
+            mjs.append(r)
+    if any(r.get("config") == base for r in offs):
+        offs = [r for r in offs if r.get("config") == base]
+    elif offs:  # no baseline run yet: one official config, the newest run's
+        newest = max(offs, key=lambda r: r.get("epoch", 0)).get("config")
+        offs = [r for r in offs if r.get("config") == newest]
+    return _merge(offs), _merge(mjs)
+
+
+def cell(rec: dict, conc: int, ctx: int) -> dict | None:
+    return next(
+        (
+            c
+            for c in rec.get("cells", [])
+            if c.get("concurrency") == conc and (c.get("context") or 0) == ctx and not c.get("prefill_phase")
+        ),
+        None,
+    )
+
+
+def value(c: dict | None, key: str) -> float | None:
+    """Mean of a metric in a cell, with fallbacks for records written before
+    TTFT/ITL were stored (ttft ← ttfr; ITL ← 1000 / decode t/s at c=1).
+    Prefill is not reported for a cell without context."""
+    if not c:
+        return None
+    if key == "pp_tps" and not (c.get("context") or 0):
+        return None  # no context, no prefill to compare: the "no ctx" row is decode only
+    m = (c.get(key) or {}).get("mean")
+    if m is not None:
+        return float(m)
+    if key == "ttft_ms":
+        return value(c, "ttfr_ms")
+    if key == "itl_ms":
+        rate = (c.get("tg_req_tps") or {}).get("mean")
+        if rate is None and (c.get("concurrency") or 1) == 1:
+            rate = (c.get("tg_tps") or {}).get("mean")
+        return 1000.0 / rate if rate else None
+    return None
+
+
+def change_pct(official: float, mjolnir: float) -> float:
+    """The relative change of the measured value, in %: (Mjolnir − official) ÷
+    official × 100. Throughput: +57% = 1.57× the tokens/s. Latency: −27% =
+    27% fewer milliseconds (a latency reduction, NOT the reciprocal speedup
+    official ÷ Mjolnir − 1, which would read +37%)."""
+    return (mjolnir / official - 1.0) * 100.0
+
+
+def gain_pct(key: str, official: float, mjolnir: float) -> float:
+    """Signed improvement of Mjolnir over official, in % — positive = better
+    whichever way the metric runs: the throughput increase for decode /
+    prefill, the latency reduction (official − Mjolnir) ÷ official for TTFT /
+    ITL. Same magnitude as :func:`change_pct`, sign flipped for latency."""
+    ch = change_pct(official, mjolnir)
+    return ch if BY_KEY[key].higher_better else -ch
+
+
+def shared_cells(off: dict, mj: dict) -> list[tuple[int, int]]:
+    """(concurrency, context) cells both records measured, sorted."""
+    a = {(c.get("concurrency"), c.get("context") or 0) for c in off.get("cells", []) if not c.get("prefill_phase")}
+    b = {(c.get("concurrency"), c.get("context") or 0) for c in mj.get("cells", []) if not c.get("prefill_phase")}
+    return sorted(a & b, key=lambda k: (k[0], k[1]))
+
+
+def all_cells(off: dict, mj: dict, max_ctx: int | None = MAX_CTX) -> list[tuple[int, int]]:
+    """(concurrency, context) cells either record measured, up to ``max_ctx``, sorted."""
+    a = {(c.get("concurrency"), c.get("context") or 0) for c in off.get("cells", []) if not c.get("prefill_phase")}
+    b = {(c.get("concurrency"), c.get("context") or 0) for c in mj.get("cells", []) if not c.get("prefill_phase")}
+    return sorted((k for k in a | b if max_ctx is None or k[1] <= max_ctx), key=lambda k: (k[0], k[1]))
+
+
+def missing_contexts(off: dict, mj: dict, max_ctx: int | None = MAX_CTX) -> dict[str, list[int]]:
+    """Contexts (up to ``max_ctx``) only one side measured: {"official": [...], "mjolnir": [...]}."""
+    ok = lambda c: max_ctx is None or (c.get("context") or 0) <= max_ctx  # noqa: E731
+    a = {c.get("context") or 0 for c in off.get("cells", []) if not c.get("prefill_phase") and ok(c)}
+    b = {c.get("context") or 0 for c in mj.get("cells", []) if not c.get("prefill_phase") and ok(c)}
+    return {"official": sorted(b - a), "mjolnir": sorted(a - b)}
+
+
+def compare(off: dict, mj: dict, every: bool = False, max_ctx: int | None = MAX_CTX) -> list[dict]:
+    """One row per shared cell (``every``: per cell either side measured, the
+    other side None): {conc, ctx, <key>: (official, mjolnir, gain%)}."""
+    rows = []
+    for conc, ctx in all_cells(off, mj, max_ctx) if every else shared_cells(off, mj):
+        a, b = cell(off, conc, ctx), cell(mj, conc, ctx)
+        row: dict = {"conc": conc, "ctx": ctx}
+        for m in METRICS:
+            va, vb = value(a, m.key), value(b, m.key)
+            row[m.key] = (va, vb, gain_pct(m.key, va, vb) if va and vb else None)
+        rows.append(row)
+    return rows
+
+
+def hero(off: dict, mj: dict, max_ctx: int | None = MAX_CTX) -> dict | None:
+    """The infographic scenario: one request (c=1), among the contexts up to
+    ``max_ctx`` where both sides measured decode AND prefill, the one with
+    the highest decode gain. {ctx, tg_tps: (off, mj, gain), pp_tps: (...), ...}."""
+    best = None
+    for conc, ctx in shared_cells(off, mj):
+        if conc != 1 or (max_ctx is not None and ctx > max_ctx):
+            continue
+        a, b = cell(off, 1, ctx), cell(mj, 1, ctx)
+        out: dict = {"ctx": ctx}
+        for key in ("tg_tps", "pp_tps", "ttft_ms", "itl_ms"):
+            va, vb = value(a, key), value(b, key)
+            out[key] = (va, vb, gain_pct(key, va, vb) if va and vb else None)
+        if out["tg_tps"][2] is None or out["pp_tps"][2] is None:
+            continue
+        if best is None or out["tg_tps"][2] > best["tg_tps"][2]:
+            best = out
+    return best
+
+
+def ctx_label(ctx: int) -> str:
+    if not ctx:
+        return "no ctx"
+    return f"{ctx // 1024}K" if ctx % 1024 == 0 else f"{ctx:,}"
+
+
+def pct(v: float | None) -> str:
+    """Signed percent with a real minus sign, 1 decimal."""
+    if v is None:
+        return "—"
+    return f"{'−' if v < 0 else '+'}{abs(v):.1f}%"
+
+
+def spec_of(rec: dict) -> dict | None:
+    """The speculative decoding a record ran with: stored in the record since
+    the field exists, else read from the config it names."""
+    if rec.get("spec") is not None:
+        return rec["spec"] or None
+    from mjolnir_cli.config import config_speculative, configs_root
+
+    path = configs_root() / str(rec.get("model", "")) / str(rec.get("config", "")) / "config.yaml"
+    return config_speculative(path) if path.exists() else None
+
+
+def spec_label(*recs: dict) -> str:
+    """``MTP, 3 speculative tokens`` (``on both sides`` / per side when they differ)."""
+
+    def one(sp: dict | None) -> str:
+        if not sp:
+            return "no speculative decoding"
+        n = sp["tokens"]
+        return f"{sp['method'].upper() or 'speculative'}, {n} speculative token{'s' if n != 1 else ''}"
+
+    labels = [one(spec_of(r)) for r in recs]
+    if len(set(labels)) == 1:
+        return labels[0]
+    return " vs ".join(labels)
+
+
+def spec_short(*recs: dict) -> str:
+    """``MTP×3`` — the compact form for tight layouts (the infographic)."""
+    labels = []
+    for r in recs:
+        sp = spec_of(r)
+        labels.append(f"{(sp['method'] or 'spec').upper()}×{sp['tokens']}" if sp else "no spec. decoding")
+    return labels[0] if len(set(labels)) == 1 else " vs ".join(labels)
+
+
+def acceptance_line(off: dict, mj: dict) -> str:
+    """'\nMTP tokens/step: 2.84 → 2.71 · preemptions 0 → 0' when both legs
+    recorded spec stats (bench runs since the counters were added). Decode
+    t/s = tokens per step / step time, so a lower acceptance length slows
+    decode with the same kernel time."""
+    a, b = off.get("spec_stats") or {}, mj.get("spec_stats") or {}
+    if not a.get("acceptance_length") or not b.get("acceptance_length"):
+        return ""
+    return (
+        f"\nspec. decoding tokens/step: {a['acceptance_length']:.2f} → {b['acceptance_length']:.2f}"
+        f" · preemptions {a.get('preemptions', 0)} → {b.get('preemptions', 0)}"
+    )
+
+
+def side_label(rec: dict) -> str:
+    return f"{rec.get('image', '')} · {rec.get('config', '')} ({rec.get('backend', '')})"

mjolnir_cli/fonts/OFL.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.