Efisiensi Pendataran Memori pada Komputasi Matriks Padat: Studi Komparatif Rust dan Go

Abstrak

Modern high-performance computing (HPC) demands face the Memory Wall, where
memory layout efficiency is now more crucial in determining performance than the number
of processor cores. Nested dynamic array structures inherently induce pointer chasing,
which breaks hardware-level data locality. This paper presents an architectural comparative
study between the concurrency models of Go (M:N scheduling) and Rust (1:1 kernel
threads) through the evaluation of intensive matrix computations on the order of 500x500
to 2000x2000. Experiments contrast conventional nested memory structures against a flat
linear layout (1D Contiguous Memory Layout). Empirical results from isolated tests show
that Go's native implementation dominates in efficiency at medium scales due to its low
Goroutine initiation overhead. However, in Rust, nested structures induce exponential
latency spikes due to high cache miss metrics. Memory flattening in Rust has been shown
journals.upi-yai.ac.id/index.php/TEKINFO/issue/archive
P-ISSN: 1411-3635
E-ISSN: 2962-5645
TEKINFO VOL. 27, NO. 2, Oktober 2026 1
to eliminate pointer chasing, reduce computational latency by up to 32.3% at the highest
order, and trigger the activation of automatic vectorization (SIMD) instructions by the
LLVM compiler. In contrast, manual application of linear index transformations in Go
actually creates a massive performance degradation of 79% due to the accumulated
arithmetic calculation load that the runtime fails to optimize. This research demonstrates
that there is no absolute language superiority; architecture selection should be based on the
alignment of Data-Oriented Design with compiler capabilities, providing concrete
recommendation parameters for designing industrial-scale software systems.