Making Convolutions Resilient via Algorithm-Based Error Detection Techniques

TL;DR

This paper investigates the use of checksum-based algorithmic error detection techniques to improve the resilience of CNN convolutions against hardware faults, achieving low overhead and high error coverage.

Contribution

It introduces practical ABED methods for CNN convolutions on optimized GPU platforms, overcoming implementation challenges and demonstrating effective error detection with minimal performance impact.

Findings

ABED detects all transient hardware errors in convolutions

Runtime overhead of ABED is between 6-23%

ABED achieves at least 1.6X throughput compared to full duplication

Abstract

The ability of Convolutional Neural Networks (CNNs) to accurately process real-time telemetry has boosted their use in safety-critical and high-performance computing systems. As such systems require high levels of resilience to errors, CNNs must execute correctly in the presence of hardware faults. Full duplication provides the needed assurance but incurs a prohibitive 100% overhead. Algorithmic techniques are known to offer low-cost solutions, but the practical feasibility and performance of such techniques have never been studied for CNN deployment platforms (e.g., TensorFlow or TensorRT on GPUs). In this paper, we focus on algorithmically verifying Convolutions, which are the most resource-demanding operations in CNNs. We use checksums to verify convolutions, adding a small amount of redundancy, far less than full-duplication. We first identify the challenges that arise in employing Algorithm-Based Error Detection (ABED) for Convolutions in optimized inference platforms that fuse multiple network layers and use reduced-precision operations, and demonstrate how to overcome them. We propose and evaluate variations of ABED techniques that offer implementation complexity, runtime overhead, and coverage trade-offs. Results show that ABED can detect all transient hardware errors that might otherwise corrupt output and does so while incurring low runtime overheads (6-23%), offering at least 1.6X throughput to workloads compared to full duplication.