Pith. sign in

REVIEW 1 major objections 27 references

Low-bit tagging is usually fastest for symbolic workloads while NaN-boxing avoids heap allocation for floats.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · grok-4.3

2026-06-28 02:21 UTC pith:2R4FYVEJ

load-bearing objection The paper refreshes tagging benchmarks on current hardware and isolates allocation versus access costs, but the microbenchmark setup leaves the real-workload claim open. the 1 major comments →

arxiv 2606.05466 v2 pith:2R4FYVEJ submitted 2026-06-03 cs.PL cs.MScs.PF

Look Before You Leap: Checking In on Type Tag Checking

Stephen M. Watt This is my paper
classification cs.PL cs.MScs.PF
keywords type taggingdynamic languagessymbolic computationperformance evaluationlow-bit taggingNaN-boxingheap allocationAArch64
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper tests the performance of three tagging approaches for dynamic values on current AArch64 and x86-64 hardware. It separates the cost of avoiding heap allocation for common scalars from the cost of reading a tag from the value itself versus from a heap object. The measurements show that several simple bit operations on the value word are cheaper than a heap memory access in many cases. This leads to the conclusion that low-bit tagging stays the simplest and fastest option for workloads dominated by symbolic data, while NaN-boxing matches access speed and removes allocation overhead for ordinary floating-point numbers.

Core claim

Experiments isolating heap-allocation cost and heap-read cost show that several local bit operations are often cheaper than opening a heap object to obtain a tag or small value. Low-bit tagging remains the simplest and usually fastest choice for mostly symbolic workloads, while NaN-boxing is close in access cost and avoids the time and space of heap allocation for ordinary floating-point values.

What carries the argument

Three tagging layouts—badged object headers, low-bit tagging, and two NaN-boxing schemes—whose relative costs are measured by microbenchmarks that separately remove heap allocation and replace heap reads with value-word bit tests.

Load-bearing premise

The microbenchmarks that isolate heap-allocation cost and heap-read cost accurately reflect the dominant costs inside real symbolic-computation and dynamic-language workloads on the tested platforms.

What would settle it

Full-system measurements of end-to-end runtime and memory use for a dynamic language interpreter or symbolic algebra system when each tagging scheme is substituted in turn on representative workloads.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Local bit operations on the value word can replace many heap reads for tag or scalar extraction.
  • Low-bit tagging remains the default choice when workloads are mostly symbolic.
  • NaN-boxing becomes competitive when floating-point values appear frequently because it eliminates their heap allocation.
  • Tagging decisions must be rechecked whenever new processor architectures or workload mixes appear.
  • The two isolated costs—allocation avoidance and tag-from-value—can be used separately to guide other representation choices.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Language implementers can use the same isolation technique to decide tagging for other data types such as small integers or rationals.
  • Workloads that mix heavy floating-point use with symbolic data may favor NaN-boxing even if pure symbolic code does not.
  • The relative advantage of bit operations over heap reads may shift on future memory systems with different latency ratios.
  • Similar microbenchmark isolation could be applied to other representation decisions such as object layout or pointer compression.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

1 major / 0 minor

Summary. The manuscript reports microbenchmark results on AArch64 and x86-64 platforms comparing badged object headers, low-bit tagging, and two NaN-boxing layouts. The experiments isolate the cost of avoiding heap allocation for scalars and the cost of local versus heap-based tag access. The results indicate that local bit operations are often cheaper than heap reads, leading to the conclusion that low-bit tagging is usually the fastest for mostly symbolic workloads while NaN-boxing is competitive and avoids float allocation.

Significance. This provides a useful recalibration of tagging performance on contemporary hardware for dynamic language implementers. The isolation of two specific effects is a methodological strength, allowing precise attribution of performance differences. The multi-platform evaluation adds robustness to the findings.

major comments (1)
  1. [Experimental Evaluation] The central claim that low-bit tagging 'remains the simplest and usually fastest choice for mostly symbolic workloads' (abstract) is load-bearing on the microbenchmarks accurately representing dominant costs in real workloads; the paper isolates allocation and tag access but does not demonstrate that these dominate over GC pressure, cache behavior, or branch mispredictions in full symbolic workloads, so the ranking could shift.

Simulated Author's Rebuttal

1 responses · 0 unresolved

We thank the referee for the detailed and constructive review. The major comment concerns the scope of our microbenchmark-based claims, which we address directly below with a commitment to partial revision.

read point-by-point responses

  1. Referee: The central claim that low-bit tagging 'remains the simplest and usually fastest choice for mostly symbolic workloads' (abstract) is load-bearing on the microbenchmarks accurately representing dominant costs in real workloads; the paper isolates allocation and tag access but does not demonstrate that these dominate over GC pressure, cache behavior, or branch mispredictions in full symbolic workloads, so the ranking could shift.

    Authors: We agree that the paper isolates the costs of avoiding scalar allocation and performing local tag access rather than measuring their dominance within complete applications. The methodological contribution, as the referee notes, is this isolation, which enables attribution of observed differences to these specific effects. The abstract claim is framed around 'mostly symbolic workloads' where tag checks on small values are frequent; our results show local bit operations are often cheaper than heap reads in that setting. However, we acknowledge that factors such as GC pressure, cache effects, and branch mispredictions are outside the measured scope and could alter rankings in full systems. We will therefore revise the abstract, introduction, and conclusions to explicitly qualify the claim as applying to the isolated costs studied, and we will add a brief discussion of the need for future full-workload validation. This constitutes a partial revision. revision: partial

Circularity Check

0 steps flagged

No circularity; empirical microbenchmark results with no derivations or self-referential reductions

full rationale

The paper reports direct timing measurements from microbenchmarks that isolate heap-allocation and heap-read costs on AArch64/x86-64. No equations, fitted parameters, predictions derived from inputs, or self-citation chains are described. The central claims rest on observed cycle counts rather than any derivation that reduces to its own assumptions by construction. This is a standard non-circular empirical study.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

This is an empirical performance study; the abstract introduces no free parameters, mathematical axioms, or postulated entities.

pith-pipeline@v0.9.1-grok · 5700 in / 1085 out tokens · 45827 ms · 2026-06-28T02:21:04.919360+00:00 · methodology

0 comments
read the original abstract

Tagging of generic dynamic values is important in symbolic-computation and dynamic-language systems, but the trade-offs change as machine architectures and workloads evolve. In particular, old folklore about boxed values, immediate values, and type tags must be recalibrated from time to time. We revisit the performance of badged object headers, low-bit tagging, and two NaN-boxing layouts on a range of platforms in use today, including AArch64 and x86-64 architectures from different manufacturers. The experiments isolate two distinct effects: the cost avoided by not heap-allocating common scalar values, and the cost avoided by obtaining tag information from the value word rather than by performing a heap read. The results show that several local bit operations are often cheaper than opening a heap object to obtain a tag or small value. Low-bit tagging remains the simplest and usually fastest choice for mostly symbolic workloads, while NaN-boxing is close in access cost and avoids the time and space of heap allocation for ordinary floating-point values.

Figures

Figures reproduced from arXiv: 2606.05466 by Stephen M. Watt.

Figure 1
Figure 1. Figure 1: Badged object headers. The type test follows the reference and reads the first word of the object. Integer and double boxes use one header word and one value word; a cons cell uses one header word and two field words. is better to read a badge from an object header or to pay the bit-manipulation cost of a tagged value. 3 Representations Tested This section describes the three representation strategies impl… view at source ↗
Figure 2
Figure 2. Figure 2: Low-bit tagging. For a tagged pointer, the low-order tag identifies the kind of value reached through the pointer. For an immediate integer, the shifted value is stored directly in the word; the tag can also distinguish signed and unsigned integer encodings. 3.2 Low-bit pointer tagging The low-bit representation uses the fact that heap objects are aligned. On now￾pervasive byte-addressed architectures, hea… view at source ↗
Figure 3
Figure 3. Figure 3: Two NaN-boxing layouts. Both preserve ordinary IEEE double-precision values. The low-tag layout stores the tag in the low-order bits of the NaN-boxed non-double value and shifts payloads to make room. The upper-tag layout stores the type tag in bits 50–48 and uses the lower 48 bits for a pointer or immediate value. to make room for it. This layout is close to low-bit pointer tagging and is useful for compa… view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

27 extracted references · 11 canonical work pages

  1. [1]

    In: Proceedings of the 2011 IEEE 17th International Symposium on High Performance Com- puter Architecture

    Anderson, O., Fortuna, E., Ceze, L., Eggers, S.J.: Checked load: Architec- tural support for JavaScript type-checking on mobile processors. In: Proceedings of the 2011 IEEE 17th International Symposium on High Performance Com- puter Architecture. pp. 419–430. HPCA ’11, IEEE Computer Society (2011). https://doi.org/10.1109/HPCA.2011.5749748

    work page doi:10.1109/hpca.2011.5749748 2011

  2. [2]

    In: Proceedings of the 1984 MACSYMA Users’ Conference

    Char, B.W., Fee, G.J., Geddes, K.O., Gonnet, G.H., Monagan, M.B., Watt, S.M.: On the design and performance of the maple system. In: Proceedings of the 1984 MACSYMA Users’ Conference. pp. 189–220 (1984)

    1984

  3. [3]

    In: van Hulzen, J.A

    Char, B.W., Geddes, K.O., Gentleman, W.M., Gonnet, G.H.: The design of maple: A compact, portable, and powerful computer algebra system. In: van Hulzen, J.A. (ed.) Computer Algebra: Proceedings of EUROCAL ’83. Lecture Notes in Computer Science, vol. 162, pp. 101–115. Springer, Berlin (1983). https://doi.org/10.1007/3-540-12868-9_95

    work page doi:10.1007/3-540-12868-9_95 1983

  4. [4]

    In: Proceedings of the 11th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages

    Deutsch, L.P., Schiffman, A.M.: Efficient implementation of the Smalltalk-80 system. In: Proceedings of the 11th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages. pp. 297–302. POPL ’84, ACM (1984). https://doi.org/10.1145/800017.800542

    work page doi:10.1145/800017.800542 1984

  5. [5]

    MIT Press, Cam- bridge, MA (1985)

    Gabriel, R.P.: Performance and Evaluation of Lisp Systems. MIT Press, Cam- bridge, MA (1985)

    1985

  6. [6]

    Kluwer Academic Publishers, Boston (1992)

    Geddes, K.O., Czapor, S.R., Labahn, G.: Algorithms for Computer Algebra. Kluwer Academic Publishers, Boston (1992)

    1992

  7. [7]

    14 David Goldberg

    Goldberg, D.: What every computer scientist should know about floating-point arithmetic. ACM Computing Surveys23(1), 5–48 (1991). https://doi.org/10.1145/103162.103163

    work page doi:10.1145/103162.103163 1991

  8. [8]

    Gudeman, D.A.: Representing type information in dynamically typed languages. Tech. Rep. TR 93-27, Department of Computer Science, University of Arizona, Tucson, AZ (Oct 1993)

    1993

  9. [9]

    International Congress on Mathematical Software 2026 (2026),https://icms-conference.org/2026/ session14.html, accessed 2026-05-10

    ICMS 2026: Session 14: Symbolic-numeric computation. International Congress on Mathematical Software 2026 (2026),https://icms-conference.org/2026/ session14.html, accessed 2026-05-10

    2026

  10. [10]

    IEEE Standard for Floating-Point Arithmetic.IEEE Std 754-2019 (Revision of IEEE 754-2008), pages 1–84, 2019

    IEEE: IEEE Standard for Floating-Point Arithmetic. IEEE Std 754-2019 (Jul 2019). https://doi.org/10.1109/IEEESTD.2019.8766229

    work page doi:10.1109/ieeestd.2019.8766229 2019

  11. [11]

    Chapman and Hall/CRC, Boca Raton, FL (2011)

    Jones, R., Hosking, A., Moss, E.: The Garbage Collection Handbook: The Art of Automatic Memory Management. Chapman and Hall/CRC, Boca Raton, FL (2011)

    2011

  12. [12]

    Proceedings of the ACM on Programming Languages9(OOPSLA2), 1620–1646 (2025)

    Melançon, O., Serrano, M., Feeley, M.: Float self-tagging. Proceedings of the ACM on Programming Languages9(OOPSLA2), 1620–1646 (2025). https://doi.org/10.1145/3763108

    work page doi:10.1145/3763108 2025

  13. [13]

    Communications in Computer Algebra48(4), 166–186 (2014)

    Monagan, M., Pearce, R.: The design of maple’s sum-of-products and POLY data structures for representing mathematical objects. Communications in Computer Algebra48(4), 166–186 (2014). https://doi.org/10.1145/2733693.2733720 Look Before You Leap 21

    work page doi:10.1145/2733693.2733720 2014

  14. [14]

    Firefox Source Docs (2026),https: //firefox-source-docs.mozilla.org/js/index.html, accessed 2026-05-05

    Mozilla: SpiderMonkey source documentation. Firefox Source Docs (2026),https: //firefox-source-docs.mozilla.org/js/index.html, accessed 2026-05-05

    2026

  15. [15]

    Archived Mozilla doc- umentation (2026),https://udn.realityripple.com/docs/Mozilla/Projects/ SpiderMonkey/Internals, accessed 2026-05-05

    Mozilla Developer Network: SpiderMonkey internals. Archived Mozilla doc- umentation (2026),https://udn.realityripple.com/docs/Mozilla/Projects/ SpiderMonkey/Internals, accessed 2026-05-05

    2026

  16. [16]

    Cambridge University Press, Cambridge (1996)

    Queinnec, C.: Lisp in Small Pieces. Cambridge University Press, Cambridge (1996)

    1996

  17. [17]

    V8 Blog (Mar 2020),https: //v8.dev/blog/pointer-compression, accessed 2026-05-05

    Sheludko, I., Solanes, S.A.: Pointer compression in V8. V8 Blog (Mar 2020),https: //v8.dev/blog/pointer-compression, accessed 2026-05-05

    2020

  18. [18]

    In: Proceedings of the 2016 IEEE International Sympo- sium on Workload Characterization

    Southern, G., Renau, J.: Overhead of deoptimization checks in the V8 JavaScript engine. In: Proceedings of the 2016 IEEE International Sympo- sium on Workload Characterization. pp. 1–10. IISWC ’16, IEEE (2016). https://doi.org/10.1109/IISWC.2016.7581268

    work page doi:10.1109/iiswc.2016.7581268 2016

  19. [19]

    In: Proceedings of the 1977 MACSYMA Users’ Conference

    Steele Jr., G.L.: Data representations in PDP-10 MACLISP. In: Proceedings of the 1977 MACSYMA Users’ Conference. pp. 203–214. NASA Scientific and Technical Information Office, Washington, DC (1977), also MIT AI Memo 420

    1977

  20. [20]

    In: Proceedings of the 1977 MAC- SYMA Users’ Conference

    Steele Jr., G.L.: Fast arithmetic in MACLISP. In: Proceedings of the 1977 MAC- SYMA Users’ Conference. pp. 215–224. NASA Scientific and Technical Information Office, Washington, DC (1977), also MIT AI Memo 421

    1977

  21. [21]

    Digital Press, Bedford, MA, 2 edn

    Steele Jr., G.L.: Common Lisp: The Language. Digital Press, Bedford, MA, 2 edn. (1990)

    1990

  22. [22]

    In: Proceedings of the Second International Conference on Architectural Support for Programming Languages and Operating Systems

    Steenkiste, P., Hennessy, J.L.: Tags and type checking in LISP: Hardware and software approaches. In: Proceedings of the Second International Conference on Architectural Support for Programming Languages and Operating Systems. pp. 50–59. ASPLOS II, ACM (1987). https://doi.org/10.1145/36206.36183

    work page doi:10.1145/36206.36183 1987

  23. [23]

    Stoutemyer, D.R.: Private communication on muLisp segment-register representa- tion (2026), private communication

    2026

  24. [24]

    In: Proceedings of the 13th Annual International Symposium on Computer Architecture

    Taylor, G.S., Hilfinger, P.N., Larus, J.R., Patterson, D.A., Zorn, B.G.: Evaluation of the SPUR Lisp architecture. In: Proceedings of the 13th Annual International Symposium on Computer Architecture. pp. 444–452. ISCA ’86, IEEE Computer Society Press (1986),https://dl.acm.org/doi/10.5555/17407.17379

    work page doi:10.5555/17407.17379 1986

  25. [25]

    (eds.): Symbolic Numeric Computation, Theo- retical Computer Science (Special Issue), vol

    Verschelde, J., Watt, S.M., Zhi, L. (eds.): Symbolic Numeric Computation, Theo- retical Computer Science (Special Issue), vol. 681. Elsevier (2017)

    2017

  26. [26]

    https://doi.org/10.5281/zenodo.20518715

    Watt, S.M.: GenericBoxTest1: Benchmark code for generic value representation experiments (2026). https://doi.org/10.5281/zenodo.20518715

    work page doi:10.5281/zenodo.20518715 2026

  27. [27]

    Source file (2026), https://github.com/WebKit/WebKit/blob/main/Source/JavaScriptCore/ runtime/JSCJSValue.h, accessed 2026-05-05

    WebKit Project: JavaScriptCore runtime source: JSCJSValue.h. Source file (2026), https://github.com/WebKit/WebKit/blob/main/Source/JavaScriptCore/ runtime/JSCJSValue.h, accessed 2026-05-05

    2026