Visual SLAM systems combine visual tracking with global loop closure to maintain a consistent map and accurate localization. Loop closure is a computationally expensive process as we need to search across the whole map for matches. This paper presents FastLoop, a GPU-accelerated loop closing module to alleviate this computational complexity. We identify key performance bottlenecks in the loop closing pipeline of visual SLAM and address them through parallel optimizations on the GPU. Specifically, we use task-level and data-level parallelism and integrate a GPU-accelerated pose graph optimization. Our implementation is built on top of ORB-SLAM3 and leverages CUDA for GPU programming. Experimental results show that FastLoop achieves an average speedup of 1.4x and 1.3x on the EuRoC dataset and 3.0x and 2.4x on the TUM-VI dataset for the loop closing module on desktop and embedded platforms, respectively, while maintaining the accuracy of the original system.
Figures & tables
Fig. 1 : Loop Closing workflow in ORB-SLAM3.
Fig. 2 : Average time spent in different sections of Loop Correction in ORB-SLAM3.
Fig. 3 : Overview of the FastLoop loop closing process. Top: CPU modules; bottom: GPU modules, with arrows showing data flow. Keyframes reside in GPU memory. White blocks mark components parallelized by FastLoop but were originally executed on the CPU.
TABLE I : Runtime (mean ± std, ms), speed-up, and ATE RMSE (m) for FastLoop vs. ORB-SLAM3 on Desktop and Jetson, using EuRoC and TUM-VI . Runtimes include H2D/D2H transfer and synchronization overhead.
Fig. 4 : Trajectory comparison between FastLoop and ORB-SLAM3 with the ground truth in Room3.
Fig. 5 : Speedup of graph optimization versus the number of poses and edges.
Fig. 6 : Timing breakdown of Projection Search, Loop Fusion, and keyframe storage in FastLoop on Corridor1 (desktop).
Sequence
LM Stop Time (ms)
KFs Refused
FastLoop
Original
FastLoop
Original
Magistrale 1
74.8
252.2
2
8
Magistrale 2
107.1
441.0
3
5
Outdoors 5
493.1
863.8
7
15
V203
42.9
58.1
1
1
TABLE II : Impact of loop correction. Local Mapping stop time (ms) and number of keyframes refused by Tracking during LM stop (desktop setting).
Sequence
System
Duration (ms)
Frames Overlapped
Latency During (ms)
Normal Latency (ms)
Magistrale1
Original
875
16
27.0
19.3
FastLoop
168
3
29.0
18.3
TABLE III : Tracking latency during Magistrale 1 largest loop closure event, ORB-SLAM3 vs. FastLoop . Normal latency is measured outside loop closure.
In real-time Visual SLAM systems, local mapping must operate under strict latency constraints, as delays degrade map quality and increase the risk of tracking failure. GPU parallelization offers a promising way to reduce latency. However, parallelizing local mapping is challenging due to synchronized shared-state updates and the overhead of transferring large map data structures to the GPU. This paper presents TurboMap, a GPU-parallelized and CPU-optimized local mapping backend that holistically addresses these challenges. We restructure Map Point Creation to enable parallel Keypoint Correspondence Search on the GPU, redesign and parallelize Map Point Fusion, optimize Redundant Keyframe Culling on the CPU, and integrate a fast GPU-based Local Bundle Adjustment solver. To minimize data transfer and synchronization costs, we introduce persistent GPU-resident keyframe storage. Experiments on the EuRoC and TUM-VI datasets show average local mapping speedups of 1.3x and 1.6x, respectively, while preserving accuracy.
Parsa Hosseininejad, Kimia Khabiri, Shishir Gopinath +3
The tracking module of a visual-inertial SLAM system processes incoming image frames and IMU data to estimate the position of the frame in relation to the map. It is important for the tracking to complete in a timely manner for each frame to avoid poor localization or tracking loss. We therefore present a new approach which leverages GPU computing power to accelerate time-consuming components of tracking in order to improve its performance. These components include stereo feature matching and local map tracking. We implement our design inside the ORB-SLAM3 tracking process using CUDA. Our evaluation demonstrates an overall improvement in tracking performance of up to 2.8x on a desktop and Jetson Xavier NX board in stereo-inertial mode, using the well-known SLAM datasets EuRoC and TUM-VI.
Kimia Khabiri, Parsa Hosseininejad, Shishir Gopinath +2
Visual-inertial SLAM on low-power edge platforms is constrained by the cost of dense feature extraction and loop closure. Prior GPU ports of ORB-SLAM trade accuracy for speed by approximating the ORB detector, altering the feature set and therefore the estimated trajectory. We present an accuracy-preserving GPU implementation of ORB-SLAM3 for the NVIDIA Jetson Orin Nano, whose GPU ORB front end reproduces the reference CPU detector algorithmically to 94.7% exact keypoint agreement and 99.9% descriptor bit agreement. This work also makes CNN-based loop closure edge-viable through native TensorRT. The visual front end (feature extraction) is offloaded to the GPU while the mapping and optimization back end is kept on the CPU, matching each computation to the hardware it suits. The accuracy is verified by comparing four configurations: the GPU pipeline and the unmodified CPU reference, each run on both the Jetson Orin Nano and a desktop. On EuRoC dataset, all four agree to within 0.10cm in mean absolute trajectory error (SE(3)), so neither the GPU port nor the change of hardware shifts the estimated trajectory. The GPU-versus-CPU comparison is reproducible on TUM-VI and KITTI datasets, so the acceleration is accuracy-preserving rather than approximate. The proposed implementation is competitive with published ORB-SLAM3 on EuRoC, attains sub-centimeter accuracy on five of the six TUM-VI room sequences, and reaches sub-1% relative translation error on nine of eleven KITTI sequences. For loop closure, the generic ONNX-Runtime CUDA/TensorRT execution providers are unusable with our CosPlace ResNet-50 on the embedded platform, whereas a native libnvinfer FP16 engine reduces per-query inference to 2.2ms, a 180x speedup. Learned place recognition therefore runs concurrently with tracking on a 7W device. In monocular-inertial mode the system sustains 32FPS mean over the eleven EuRoC sequences.