Efficient implementations of self-checking multiply and divide arrays

Nicolaidis, M.; Bederr, H.

doi:10.1109/edtc.1994.326816

Cited by 13 publications

(2 citation statements)

References 8 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The naive approach to computational error correction is TMR [86], requiring over a 200% overhead in area and energy for single error correcting capability. Several techniques in the form of arithmetic codes such as AN codes [6,18,19,41,66,88], self-checking [30,33,44,[48][49][50]84], and self-correcting [15,20,26,37,45,55,62,63,74,83] adders and multipliers have since been devised. Orthogonally, proposals employ redundancy at a higher granularity, such as timing speculation (wherein error correction capability is limited to circuit timing violations) [16,23], partial pipeline replication [2], or checkpoint-rollback-recovery such as those in IBM Power8 processors [29].…”

Section: Related Workmentioning

confidence: 99%

Extending Moore’s Law via Computationally Error-Tolerant Computing

Deng

Srikanth

Hein

et al. 2018

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

Dennard scaling has ended. Lowering the voltage supply (V dd) to sub-volt levels causes intermittent losses in signal integrity, rendering further scaling (down) no longer acceptable as a means to lower the power required by a processor core. However, it is possible to correct the occasional errors caused due to lower V dd in an efficient manner and effectively lower power. By deploying the right amount and kind of redundancy, we can strike a balance between overhead incurred in achieving reliability and energy savings realized by permitting lower V dd. One promising approach is the Redundant Residue Number System (RRNS) representation. Unlike other error correcting codes, RRNS has the important property of being closed under addition, subtraction and multiplication, thus enabling computational error correction at a fraction of an overhead compared to conventional approaches. We use the RRNS scheme to design a Computationally-Redundant, Energy-Efficient core, including the microarchitecture, Instruction Set Architecture (ISA) and RRNS centered algorithms. From This paper is an extension of "Computationally-Redundant Energy-Efficient Processing for Y'all (CREEPY)" [11]. This submission adds the following: (1) Correction factor analysis for RRNS signed arithmetic, including an improved correction factor computation for signed multiplication via an LUT based mechanism. (Section 4.8.5) (2) Design and evaluation of an efficient RRNS multiplier unit by using the index-sum technique, along with associated re-derivation of suitable RRNS bases. (Sections 4.4 and 4.5) (3) A novel adaptive check insertion strategy that leverages hardware/software runtime or compiler. (Section 4.6.3) (4) Impact of multi-domain voltage supply to further lower energy consumption. (Sections 4.7, 6.1 and 6.3) (5) Improved evaluation accuracy by simulating an LLC-main memory hierarchy instead of a perfect cache. (Section 5) (6) Energy limit analysis for binary, RNS and RRNS cores. (Section 6) These add significantly more than 30% new material and provide greater insight into RRNS core design. W.r.t. written content, every section has been revamped to better present the new findings above.

show abstract

Section: Related Workmentioning

confidence: 99%

Extending Moore’s Law via Computationally Error-Tolerant Computing

Deng

Srikanth

Hein

et al. 2018

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

show abstract

“…Nikolaidis [13] propose efficient parity prediction techniques to achieve (detection only) low area overhead of 17% for carry lookahead adders. As noted by the residue based detection work of Pan et al [14], Nikolaidis et al propose [15] using differential logic circuits to implement each cell of array-based multipliers, and, also propose [16] output duplicated Booth multipliers, again, for detection alone. The latter was improved upon by Marienfeld et al [17] to achieve a hardware overhead of 35% for detection in 32 bit multipliers.…”

Section: Micro-architectural / Isa Independent Techniquesmentioning

confidence: 99%

A Brief Survey of Non-Residue Based Computational Error Correction

Srikanth¹,

Deng²,

Conte³

2016

Preprint

View full text Add to dashboard Cite

The idea of computational error correction has been around for over half a century. The motivation has largely been to mitigate unreliable devices, manufacturing defects or harsh environments, primarily as a mandatory measure to preserve reliability, or more recently, as a means to lower energy by allowing soft errors to occasionally creep. While residue codes have shown great promise for this purpose, there have been several orthogonal non-residue based techniques. In this article, we provide a high level outline of some of these non-residual approaches. OverviewWe first classify various approaches to computational error correction into two broad categories:1. Temporal Redundancy. This approach is based on the hypothesis that the probability of transient errors that occur at the same place to have temporal multiplicity is very low. In other words, a soft error occurs infrequently at the same device, and as such, repeated measurements in some manner would serve as an indicator to the correct computation.2. Spatial Redundancy. This approach is based on the hypothesis that the probability of multiple identical computations to all be in error at the same time is very low. In other words, by replicating a computation, any error in a small fraction of the replicas can be masked / overpowered by the other correct replicas.These principles, it turns out, are fundamental to any sort of error correction including computation (ex. arithmetic), storage (ex. memory) and transmission (ex. networking). Some proposals favor spatial redundancy over temporal redundancy, some vice versa, and some employ both, depending upon the target fault model and environment. Given a technique, it is relatively straightforward to determine presence of temporal and/or spatial redundancy, as such, we leave this to the interested reader.Von Neumann [1] was among the first to propose using redundant components to overcome the effects of defective devices. He introduced the now widely used technique of Triple Modular Redundancy (TMR), which essentially uses three devices instead of one and uses a majority voter to infer a correct output. To note here is that such a mechanism can correct a single error (meaning that at least two of the three devices are not in error), or detect most double errors (where at least

show abstract

On the effectiveness of residue code checking for parallel two's complement multipliers

Sparmann

Reddy

1996

IEEE Trans. VLSI Syst.

View full text Add to dashboard Cite

Efficient implementations of self-checking multiply and divide arrays

Cited by 13 publications

References 8 publications

Extending Moore’s Law via Computationally Error-Tolerant Computing

Extending Moore’s Law via Computationally Error-Tolerant Computing

A Brief Survey of Non-Residue Based Computational Error Correction

On the effectiveness of residue code checking for parallel two's complement multipliers

Contact Info

Product

Resources

About