Automatic Reference Counting Implementation and Optimization of the Octave JIT Compiler for High-Performance Computing Platforms

Reference counting, a venerable technique, has seen a resurgence owing to recent advancements. This resurgence holds particular significance for dynamic languages, which have historically faced constraints linked to traditional reference counting issues, thus standing to greatly benefit from these advancements. However, implementing reference counting in Just-In-Time (JIT) compilers for dynamic languages presents significant challenges. These challenges originate from two main sources: the intrinsic properties of dynamic languages and the application requirements of high-performance computing (HPC) platforms. Taking Octave, a dynamic language celebrated for its matrix computation capabilities, as a case study, we delved into and refined the memory management mechanisms of its JIT compiler. By resolving the correctness issues in these mechanisms, we shed light on the complexities surrounding the integration of automatic reference counting (ARC) algorithms from static to dynamic languages. Moreover, within the realm of HPC platforms, we emphasize the critical role of timely garbage collection for dynamic languages. Consequently, we introduce an ARC algorithm tailor-made for HPC environments, demonstrating through experiments that this algorithm effectively enhances memory management, curtails memory utilization, expedites program execution, and significantly mitigates excessive memory access across Non-Uniform Memory Access (NUMA) nodes. Our findings unveil novel strategies for memory management and JIT compilation in dynamic languages, underscoring ARC's potential to streamline complex data structure management, ease the burden on compiler developers, and boost the execution speed of dynamic languages.

I. Introduction

Reference counting, a prevalent strategy in memory management, identifies the opportune moment for object release by monitoring each object's reference count. Initially, dynamic languages, particularly domain-specific ones like Octave, predominantly utilized reference counting for memory management. However, as these languages evolved, the simplicity of this strategy revealed weaknesses in managing complex data structures and optimizing for HPC Platforms. Consequently, contemporary programming languages have shifted towards more sophisticated garbage collection algorithms, enhancing memory management and program efficiency. Nevertheless, recent studies have underscored the continued efficacy and scalability of reference counting within modern concurrent programming environments [1], [2], thus reaffirming its application value.