versioned pointers

This work addresses the challenge of knowledge updating in large language models, which typically necessitates costly retraining. Building upon the Compositional Multi-layer Memory (CMM) architecture, the authors propose a version-aware operational layer that compiles high-level semantic edits into ordered, composable memory primitive transactions. By introducing versioned CMM and transactional CMM, knowledge modifications are modeled as reversible and reusable structured transactions, enabling fine-grained replacement, rollback, historical tracing, and localized updates. This approach substantially reduces reliance on full model retraining while ensuring editing efficiency and traceability.

This work addresses the combinatorial explosion in memory and time that plagues scalable flow- and context-sensitive pointer analysis, where existing optimizations often compromise precision. To overcome this challenge, the authors propose a Multi-level Deduplication Engine (MDE) that recursively identifies structured redundancies, assigns unique identifiers to equivalent computation states, and integrates memoization of operations to enable efficient reuse—thereby surpassing the limitations of traditional non-recursive deduplication techniques. Implemented in C++ and integrated into a pointer analysis framework, MDE demonstrates substantial performance gains on the SPEC benchmark suite, achieving up to an 18.1× reduction in peak memory usage and an 8.15× speedup in runtime. Notably, the optimization benefits intensify with increasing program scale, highlighting MDE’s effectiveness for large real-world applications.

Traditional multiversion concurrency control incurs high overhead and frequent read-write conflicts during range scans, while multiversion B-trees (MVBTs) support efficient arbitrary-version scans but lack practical concurrency mechanisms. This work proposes concurrent MVBT (cMVBT), the first MVBT variant equipped with an efficient concurrency control protocol: write operations employ optimistic locking, range scans are entirely lock-free, and the design integrates smooth, peak-free continuous garbage collection with space management. Experimental results demonstrate that under standard mixed workloads, cMVBT significantly outperforms version-chain-based approaches, achieving low overhead, high write throughput, and superior range scan performance.

This work addresses the problem of outdated references in Linux kernel comments caused by function refactoring or deletion, which mislead developers and impede code comprehension. The authors propose ReCite, the first approach specifically targeting such externally induced comment obsolescence, integrating static symbol resolution, Git evolution history tracing, and large language models (LLMs) within a three-stage pipeline to accurately detect stale references and generate repair suggestions. Evaluated on Linux kernel v6.18-rc1, ReCite identified 869 outdated references; manual assessment of 200 repair suggestions showed that 89.0% provided actionable guidance and 42.5% were directly applicable. Of the 75 patches submitted to the community, 50 have already been accepted, demonstrating substantial improvement over traditional methods relying solely on semantic alignment.

Semantic conflicts—semantic inconsistencies arising despite syntactically correct text merges—are poorly detected by existing merge tools, while static analysis approaches suffer from low precision and high false-positive rates. This paper systematically investigates the role of pointer analysis in static semantic conflict detection: we design and evaluate two detectors—with and without pointer analysis—on two real-world datasets. Results show that incorporating pointer analysis significantly reduces false positives and timeout rates, but at the cost of substantially degraded recall and F1 score, leading to a sharp increase in missed detections. This reveals the fundamental limitations of relying on a single static analysis paradigm. We thus propose, for the first time, a hybrid detection framework that integrates coarse-grained (high-recall) and fine-grained (high-precision) analyses—balancing accuracy and practicality. Our approach offers a scalable, principled solution to semantic conflict detection in software merging.

This work addresses atomicity violations in concurrent programs—a prevalent source of concurrency bugs—by introducing AtomSanitizer, a novel stream-based conflict serializability detection algorithm. AtomSanitizer achieves a time complexity of O(nk²), substantially outperforming existing approaches, and integrates a lightweight runtime monitoring mechanism within the ThreadSanitizer (TSAN) framework to enable low-overhead, real-time atomicity validation. Experimental evaluation demonstrates that AtomSanitizer consistently outperforms state-of-the-art detectors on standard benchmarks, with both time and memory overheads comparable to those of TSAN’s data race detection, thereby offering an efficient solution for runtime atomicity monitoring in concurrent software.

Traditional redundancy mechanisms are vulnerable to common-mode failures because replicated program instances share identical memory layouts and code. To address this limitation, this work proposes a structured address space decorrelation approach that generates multiple semantically equivalent program variants through independent compilation, each exhibiting distinct memory layouts. At runtime, the method extracts normalized instruction traces—comprising opcodes, registers, operands, and results—while eliminating address dependencies, and performs cross-variant comparison to detect faults. This technique effectively identifies common-mode errors induced by arbitrary program counter jumps or data pointer corruptions, thereby significantly enhancing the capability of runtime semantic consistency verification.

Traditional reader-writer locks suffer from coarse-grained contention, making them ill-suited for concurrent data structures involving long-running operations. This work proposes SemanticLock, a synchronization mechanism that generalizes read-write semantics to arbitrary semantic conflict relationships among operations. By constructing an operation conflict graph, SemanticLock enables fine-grained concurrency control while allowing flexible specification of operation semantics. The approach has been integrated into array-based structures supporting both point and range queries, as well as an enhanced ConcurrentHashMap. Experimental results demonstrate that SemanticLock substantially improves concurrency performance under complex, long-duration operations.

This work proposes an efficient and robust lock-free multi-word compare-and-swap (MCAS) algorithm that addresses the severe performance degradation under high contention and susceptibility to the ABA problem observed in existing approaches, which can lead to state inconsistency and redundant operation execution. The proposed algorithm incorporates a contention-aware helping mechanism that dynamically adjusts the number of concurrent helpers and integrates version embedding to effectively mitigate ABA issues. By combining exponential backoff, embedded counters, and a fast garbage collection path, the method ensures state consistency while significantly improving throughput. Experimental results demonstrate that the algorithm achieves up to three times the throughput of the current state-of-the-art lock-free MCAS implementation and successfully eliminates ABA-related errors in practical scenarios.