arXiv subjects

Swarnendu Biswas

Publications and source records attributed to Swarnendu Biswas.

6 recordsLinked to original sources

arXiv2022

Efficient Data Race Detection of Async-Finish Programs Using Vector Clocks

Existing data race detectors for task-based programs incur significant run time and space overheads. The overheads arise because of frequent lookups in fine-grained tree data structures to check whether two accesses can happen in parallel. This work shows how to efficiently apply vector clocks for dynamic data race detection of async-finish programs with locks. Our proposed technique, FastRacer, builds on the FastTrack algorithm with per-task and per-variable optimizations to reduce the size of vector clocks. FastRacer exploits the structured parallelism of async-finish programs to use a coarse-grained encoding of the dynamic task inheritance relations to limit the metadata in the presence of many concurrent readers. Our evaluation shows that FastRacer substantially improves time and space overheads over FastTrack, and is competitive with the state-of-the-art data race detectors for async-finish programs with locks.

cs.PL↗

arXiv2021

Predictive Data Race Detection for GPUs

The high degree of parallelism and relatively complicated synchronization mechanisms in GPUs make writing correct kernels difficult. Data races pose one such concurrency correctness challenge, and therefore, effective methods of detecting as many data races as possible are required. Predictive partial order relations for CPU programs aim to expose data races that can be hidden during a dynamic execution. Existing predictive partial orders cannot be naïvely applied to analyze GPU kernels because of the differences in programming models. This work proposes GWCP, a predictive partial order for data race detection of GPU kernels. GWCP extends a sound and precise relation called weak-causally-precedes (WCP) proposed in the context of multithreaded shared memory CPU programs to GPU kernels. GWCP takes into account the GPU thread hierarchy and different synchronization semantics such as barrier synchronization and scoped atomics and locks. We implement a tool called PreDataR that tracks the GWCP relation using binary instrumentation. PreDataR includes three optimizations and a novel vector clock compression scheme that are readily applicable to other partial order based analyses. Our evaluation with several microbenchmarks and benchmarks shows that PreDataR has better data race coverage compared to prior techniques at practical run-time overheads.

cs.PL↗

arXiv2021

Neat: Low-Complexity, Efficient On-Chip Cache Coherence

Cache coherence protocols such as MESI that use writer-initiated invalidation have high complexity and sometimes have poor performance and energy usage, especially under false sharing. Such protocols require numerous transient states, a shared directory, and support for core-to-core communication, while also suffering under false sharing. An alternative to MESI's writer-initiated invalidation is self-invalidation, which achieves lower complexity than MESI but adds high performance costs or relies on programmer annotations or specific data access patterns. This paper presents Neat, a low-complexity, efficient cache coherence protocol. Neat uses self-invalidation, thus avoiding MESI's transient states, directory, and core-to-core communication requirements. Neat uses novel mechanisms that effectively avoid many unnecessary self-invalidations. An evaluation shows that Neat is simple and has lower verification complexity than the MESI protocol. Neat not only outperforms state-of-the-art self-invalidation protocols, but its performance and energy consumption are comparable to MESI's, and it outperforms MESI under false sharing.

cs.AR↗

arXiv2019

An Elementary Introduction to Kalman Filtering

Kalman filtering is a classic state estimation technique used in application areas such as signal processing and autonomous control of vehicles. It is now being used to solve problems in computer systems such as controlling the voltage and frequency of processors. Although there are many presentations of Kalman filtering in the literature, they usually deal with particular systems like autonomous robots or linear systems with Gaussian noise, which makes it difficult to understand the general principles behind Kalman filtering. In this paper, we first present the abstract ideas behind Kalman filtering at a level accessible to anyone with a basic knowledge of probability theory and calculus, and then show how these concepts can be applied to the particular problem of state estimation in linear systems. This separation of concepts from applications should make it easier to understand Kalman filtering and to apply it to other problems in computer systems.

eess.SY↗

arXiv2018

SLAMBooster: An Application-aware Controller for Approximation in SLAM

Simultaneous Localization and Mapping (SLAM) is the problem of constructing a map of a mobile agent's environment while localizing the agent within the map. Dense SLAM algorithms perform reconstruction and localization at pixel granularity. These algorithms require a lot of computational power, which has hindered their use on low-power resource-constrained devices. Approximate computing can be used to speed up SLAM implementations as long as the approximations do not prevent the agent from navigating correctly through the environment. Previous studies of approximation in SLAM have assumed that the entire trajectory of the agent is known before the agent starts, and they have focused on offline controllers that set approximation knobs at the start of the trajectory. In practice, the trajectory is not known ahead of time, and allowing knob settings to change dynamically opens up more opportunities for reducing computation time and energy. We describe SLAMBooster, an application-aware, online control system for dense SLAM that adaptively controls approximation knobs during the motion of the agent. SLAMBooster is based on a control technique called proportional-integral-derivative (PID) controller but our experiments showed this application-agnostic controller led to an unacceptable reduction in localization accuracy. To address this problem, SLAMBooster also exploits domain knowledge for controlling approximation by performing smooth surface detection and pose correction. We implemented SLAMBooster in the open-source SLAMBench framework and evaluated it on several trajectories. Our experiments show that on the average, SLAMBooster reduces the computation time by 72% and energy consumption by 35% on an embedded platform, while maintaining the accuracy of localization within reasonable bounds. These improvements make it feasible to deploy SLAM on a wider range of devices.

cs.RO↗

arXiv2017

Capri: A Control System for Approximate Programs

Approximate computing trades off accuracy of results for resources such as energy or computing time. There is a large and rapidly growing literature on approximate computing that has focused mostly on showing the benefits of approximation. However, we know relatively little about how to control approximation in a disciplined way. This document briefly describes our published work of controlling approximation for non-streaming programs that have a set of "knobs" that can be dialed up or down to control the level of approximation of different components in the program. The proposed system, Capri, solves this control problem as a constrained optimization problem. Capri uses machine learning to learn cost and error models for the program, and uses these models to determine, for a desired level of approximation, knob settings that optimize metrics such as running time or energy usage. Experimental results with complex benchmarks from different problem domains demonstrate the effectiveness of this approach. This report outlines improvements and extensions to the existing Capri system to address its limitations, including a complete rewrite of the software, and discusses directions for follow up work. The document also includes instructions and guidelines for using the new Capri infrastructure.

cs.PL↗