All content written by Owen Nicholson, CEO SLAMcore Ltd.
Computational efficiency is as important as accuracy for commercial-grade SLAM
SLAM algorithms aim to estimate the position of a machine as it moves through space. It is very important that this estimate is accurate which is why accuracy is the main metric that most companies look to evaluate potential options against. The accuracy of SLAMcore’s solution outperforms open-source and commercial alternatives, quite often by an order of magnitude. While accuracy is the typical battleground for SLAM algorithms, there is an additional but essential performance metric that is quite often overlooked: Computational efficiency.
To get the best out of your Arm processors embedded in robotic devices, you need SLAM algorithms that make both low and consistent demands on compute and memory resources. Arm processors are perfect for edge devices including robots and other autonomous systems. They provide low-power, high-performance hardware with small footprints ideal for the space, weight, and power-constrained world of mobile robots. Selecting the right simultaneous localization and mapping (SLAM) algorithms to work with them is essential if their memory and compute performance is to be optimized.
SLAM is a central element of the overall autonomy stack, and there are several parameters that designers must take into consideration when selecting or designing SLAM algorithms. These parameters can include: the range of sensors required, the cost, the weight they add, accuracy of the mapping and location needed, and the ability to handle the wide range of scenarios encountered in the real-world. Often overlooked in evaluation and prototyping is the computational efficiency of the SLAM software. Embedded processors must run numerous tasks simultaneously, ensuring the maximum efficiency of each, while minimizing the load on the processor. This is fundamental to creating robots that are not only highly capable, but affordable. Arm architectures are perfect for this type of work, but it is essential that software utilizes their resources efficiently.
Unfortunately, many open-source and commercial SLAM implementations have problems with both very high compute and memory requirements and highly unpredictable demands on compute and memory resources.
Peaks and large magnitude swings in processor and memory requirements are hard for system architects to design around. Designing for the average demand runs the risk that the peaks could overwhelm the processor, prevent other tasks from being accomplished, or fail to complete SLAM estimations in a timely fashion. To avoid this, developers are forced to over-specify the processor based on the peak demands with the result that they end up paying more for silicon.
The graphs here illustrate the resource requirements of SLAMcore’s SLAM software compared to a recent state-of-the-art, open-source alternative. Both sets of software are running in the ‘out-of-the-box’ state with no additional specific tuning. Both are running on the same system with Arm v8.2 architecture processors, taking data from the same sensor set-up with stereo RGB cameras and an inertial measurement unit (IMU).
The plots show the processor load and memory usage running on the same data. The first thing you will notice is that the open-source software is not able to process the data in real-time. It runs 2.8 times slower than real-time so that means when running live, nearly two thirds of the sensor data will be dropped. This will impact accuracy and reliability significantly.
It is also clear that the SLAMcore software uses much less processor, from the perspective of both average and maximum load. These differences are important. The consistent and computationally efficient demands of the SLAMcore software make it much easier for designers to predict the correct amount of compute resources needed for effective SLAM. They can factor this into designs and be confident in the resource available for other software.
The same is also true for memory. As the graph shows, the open-source system rapidly makes much higher demand on memory resources as the map is computed. The SLAMcore system manages memory far more efficiently, not only reducing the overall memory required to process maps, but also increasing the speed of position estimates. A more memory-efficient map can be processed faster leading to more accurate SLAM.
As more robots are fulfilling important roles in the world around us, effective and affordable combinations of hardware and software are essential for commercially viable deployments. In some situations, open-source software provides a cost-effective element of the overall autonomy stack and can short-cut prototyping and proof of concept work. But for commercial deployment at scale, designers should consider the computational efficiency of spatial intelligence algorithms as well as their accuracy.
Small savings made in software at the development stage could lead to less-efficient use of the processing and memory resources and higher silicon costs in production robots. SLAMcore delivers production-ready spatial intelligence out of the box. Downloadable SDKs provide rapid prototyping capability, but the same algorithms scale to cover the complexity and uncertainty of real-world deployments. Developers can be certain that what worked in the lab will work in production.
Commercially viable robots need commercially viable SLAM software that makes predictable demands on the most widely used processors in edge robotics. SLAMcore’s proprietary algorithms have been designed from the bottom up to maximize both accuracy and efficiency. SLAMcore’s team of world-leading experts has built on decades of experience to deliver solutions to SLAM problems faced by engineers building robots for a wide range of applications. As part of the Arm Developer Ecosystem these solutions are optimized for Arm designs and give consistent, accurate and resilient SLAM out of the box helping to reduce costs and increase time to market for exciting innovations utilizing these processors.
For a more in-depth look at SLAMcore technology
check out this webinar
that goes into further detail about the power of SLAM on embedded devices.