Performance Impact of Lock-Free Algorithms on Multicore Communication APIs

TL;DR

This paper explores how lock-free algorithms improve communication latency and throughput in multicore systems, demonstrating significant performance gains over traditional lock-based methods in embedded and general computing environments.

Contribution

It introduces a lock-free multicore communication API, models its performance, and compares it with lock-based approaches, highlighting advantages in latency and throughput.

Findings

Lock-free messaging reduces data exchange latency.

Performance degrades for lock-based methods on multicore architectures.

Lock-free algorithms improve throughput and scalability.

Abstract

Data race conditions in multi-tasking software applications are prevented by serializing access to shared memory resources, ensuring data consistency and deterministic behavior. Traditionally tasks acquire and release locks to synchronize operations on shared memory. Unfortunately, lock management can add significant processing overhead especially for multicore deployments where tasks on different cores convoy in queues waiting to acquire a lock. Implementing more than one lock introduces the risk of deadlock and using spinlocks constrains which cores a task can run on. The better alternative is to eliminate locks and validate that real-time properties are met, which is not directly considered in many embedded applications. Removing the locks is non-trivial and packaging lock-free algorithms for developers reduces the possibility of concurrency defects. This paper details how a multicore communication API implementation is enhanced to support lock-free messaging and the impact this has on data exchange latency between tasks. Throughput and latency are compared on Windows and Linux between lock-based and lock-free implementations for data exchange of messages, packets, and scalars. A model of the lock-free exchange predicts performance at the system architecture level and provides a stop criterion for the refactoring. The results show that migration from single to multicore hardware architectures degrades lock-based performance, and increases lock-free performance.