Results 1  10
of
50
Neural Acceleration for GeneralPurpose Approximate Programs
"... This paper describes a learningbased approach to the acceleration of approximate programs. We describe the Parrot transformation, a program transformation that selects and trains a neural network to mimic a region of imperative code. After the learning phase, the compiler replaces the original code ..."
Abstract

Cited by 49 (12 self)
 Add to MetaCart
(Show Context)
This paper describes a learningbased approach to the acceleration of approximate programs. We describe the Parrot transformation, a program transformation that selects and trains a neural network to mimic a region of imperative code. After the learning phase, the compiler replaces the original code with an invocation of a lowpower accelerator called a neural processing unit (NPU). The NPU is tightly coupled to the processor pipeline to accelerate small code regions. Since neural networks produce inherently approximate results, we define a programming model that allows programmers to identify approximable code regions—code that can produce imprecise but acceptable results. Offloading approximable code regions to NPUs is faster and more energy efficient than executing the original code. For a set of diverse applications, NPU acceleration provides wholeapplication speedup of 2.3 × and energy savings of 3.0 × on average with quality loss of at most 9.6%. 1.
Verifying Quantitative Reliability for Programs That Execute on Unreliable Hardware
"... Emerging highperformance architectures are anticipated to contain unreliable components that may exhibit soft errors, which silently corrupt the results of computations. Full detection and masking of soft errors is challenging, expensive, and, for some applications, unnecessary. For example, approx ..."
Abstract

Cited by 25 (3 self)
 Add to MetaCart
(Show Context)
Emerging highperformance architectures are anticipated to contain unreliable components that may exhibit soft errors, which silently corrupt the results of computations. Full detection and masking of soft errors is challenging, expensive, and, for some applications, unnecessary. For example, approximate computing applications (such as multimedia processing, machine learning, and big data analytics) can often naturally tolerate soft errors. We present Rely, a programming language that enables developers to reason about the quantitative reliability of an application – namely, the probability that it produces the correct result when executed on unreliable hardware. Rely allows developers to specify the reliability requirements for each value that a function produces. We present a static quantitative reliability analysis that verifies quantitative requirements on the reliability of an application, enabling a developer to perform sound and verified reliability engineering. The analysis takes a Rely program with a reliability specification and a hardware specification that characterizes the reliability of the underlying hardware components and verifies that the program satisfies its reliability specification when executed on the underlying unreliable hardware platform. We demonstrate the application of quantitative reliability analysis on six computations implemented
Approximate Computing: An Emerging Paradigm for EnergyEfficient Design
 Proceedings of the 18th IEEE European Test Symposium
, 2013
"... Abstract — Approximate computing has recently emerged as a promising approach to energyefficient design of digital systems. Approximate computing relies on the ability of many systems and applications to tolerate some loss of quality or optimality in the computed result. By relaxing the need for fu ..."
Abstract

Cited by 20 (10 self)
 Add to MetaCart
(Show Context)
Abstract — Approximate computing has recently emerged as a promising approach to energyefficient design of digital systems. Approximate computing relies on the ability of many systems and applications to tolerate some loss of quality or optimality in the computed result. By relaxing the need for fully precise or completely deterministic operations, approximate computing techniques allow substantially improved energy efficiency. This paper reviews recent progress in the area, including design of approximate arithmetic blocks, pertinent error and quality measures, and algorithmlevel techniques for approximate computing. Keywords—approximate computing, probabilistic computing, stochastic computation, adder, multiplier, lowenergy design I. IMPRECISION TOLERANCE AND ENERGY REDUCTION Energyefficiency has become the paramount concern in
Approximate storage in solidstate memories
 In Proc. Int. Symp. Microarchitecture
, 2013
"... Memories today expose an allornothing correctness model that incurs significant costs in performance, energy, area, and design complexity. But not all applications need highprecision storage for all of their data structures all of the time. This paper proposes mechanisms that enable applications ..."
Abstract

Cited by 19 (3 self)
 Add to MetaCart
(Show Context)
Memories today expose an allornothing correctness model that incurs significant costs in performance, energy, area, and design complexity. But not all applications need highprecision storage for all of their data structures all of the time. This paper proposes mechanisms that enable applications to store data approximately and shows that doing so can improve the performance, lifetime, or density of solidstate memories. We propose two mechanisms. The first allows errors in multilevel cells by reducing the number of programming pulses used to write them. The second mechanism mitigates wearout failures and extends memory endurance by mapping approximate data onto blocks that have exhausted their hardware error correction resources. Simulations show that reducedprecision writes in multilevel phasechange memory cells can be 1.7 × faster on average and using failed blocks can improve array lifetime by 23 % on average with quality loss under 10%.
Energy types
 In OOPSLA’12
, 2012
"... This paper presents a novel type system to promote and facilitate energyaware programming. Energy Types is built upon a key insight into today’s energyefficient systems and applications: despite the popular perception that energy and power can only be described in joules and watts, realworld ener ..."
Abstract

Cited by 17 (4 self)
 Add to MetaCart
(Show Context)
This paper presents a novel type system to promote and facilitate energyaware programming. Energy Types is built upon a key insight into today’s energyefficient systems and applications: despite the popular perception that energy and power can only be described in joules and watts, realworld energy management is often based on discrete phases and modes, which in turn can be reasoned about by type systems very effectively. A phase characterizes a distinct pattern of program workload, and a mode represents an energy state the program is expected to execute in. This paper describes a programming model where phases and modes can be intuitively specified by programmers or inferred by the compiler as type information. It demonstrates how a typebased approach to reasoning about phases and modes can help promote energy efficiency. The soundness of our type system and the invariants related to interphase and intermode interactions are rigorously proved. Energy Types is implemented as the core of a prototyped objectoriented language ET for smartphone programming. Preliminary studies show ET can lead to significant energy savings for Android Apps.
SAGE: Selftuning approximation for graphics engines
 In Proc. of the 46th Annual International Symposium on Microarchitecture
, 2013
"... Approximate computing, where computation accuracy is traded off for better performance or higher data throughput, is one solution that can help data processing keep pace with the current and growing overabundance of information. For particular domains such as multimedia and learning algorithms, app ..."
Abstract

Cited by 16 (4 self)
 Add to MetaCart
(Show Context)
Approximate computing, where computation accuracy is traded off for better performance or higher data throughput, is one solution that can help data processing keep pace with the current and growing overabundance of information. For particular domains such as multimedia and learning algorithms, approximation is commonly used today. We consider automation to be essential to provide transparent approximation and we show that larger benefits can be achieved by constructing the approximation techniques to fit the underlying hardware. Our target platform is the GPU because of its high performance capabilities and difficult programming challenges that can be alleviated with proper automation. Our approach, SAGE, combines a static compiler that automatically generates a set of CUDA kernels with varying levels of approximation with a runtime system that iteratively selects among the available kernels to achieve speedup while adhering to a target output quality set by the user. The SAGE compiler employs three optimization techniques to generate approximate kernels that exploit the GPU microarchitecture: selective discarding of atomic operations, data packing, and thread fusion. Across a set of machine learning and image processing kernels, SAGE’s approximation yields an average of 2.5x speedup with less than 10 % quality loss compared to the accurate execution on a NVIDIA GTX 560 GPU.
Paraprox: patternbased approximation for data parallel applications
 In 19th International Conference on Architectural Support for Programming Languages and Operating Systems
, 2014
"... Approximate computing is an approach where reduced accuracy of results is traded off for increased speed, throughput, or both. Loss of accuracy is not permissible in all computing domains, but there are a growing number of dataintensive domains where the output of programs need not be perfectly ..."
Abstract

Cited by 12 (3 self)
 Add to MetaCart
(Show Context)
Approximate computing is an approach where reduced accuracy of results is traded off for increased speed, throughput, or both. Loss of accuracy is not permissible in all computing domains, but there are a growing number of dataintensive domains where the output of programs need not be perfectly correct to provide useful results or even noticeable differences to the end user. These soft domains include multimedia processing, machine learning, and data mining/analysis. An important challenge with approximate computing is transparency to insulate both software and hardware developers from the time, cost, and difficulty of using approximation. This paper proposes a softwareonly system, Paraprox, for realizing transparent approximation of dataparallel programs that operates on commodity hardware systems. Paraprox starts with a dataparallel kernel implemented using OpenCL or CUDA and creates a parameterized approximate kernel that is tuned at runtime to maximize performance subject to a target output quality (TOQ) that is supplied by the user. Approximate kernels are created by recognizing common computation idioms found in dataparallel programs (e.g., Map, Scatter/Gather, Reduction, Scan, Stencil, and Partition) and substituting approximate implementations in their place. Across a set of 13 soft dataparallel applications with at most 10 % quality degradation, Paraprox yields an average performance gain of 2.7x on a NVIDIA GTX 560 GPU and 2.5x on an Intel Core i7 quadcore processor compared to accurate execution on each platform.
EnergyEfficient WorkStealing Language Runtimes
"... Work stealing is a promising approach to constructing multithreaded program runtimes of parallel programming languages. This paper presents HERMES, an energyefficient workstealing language runtime. The key insight is that threads in a workstealing environment – thieves and victims – have varying ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
(Show Context)
Work stealing is a promising approach to constructing multithreaded program runtimes of parallel programming languages. This paper presents HERMES, an energyefficient workstealing language runtime. The key insight is that threads in a workstealing environment – thieves and victims – have varying impacts on the overall program running time, and a coordination of their execution “tempo ” can lead to energy efficiency with minimal performance loss. The centerpiece of HERMES is two complementary algorithms to coordinate thread tempo: the workpathsensitive algorithm determines tempo for each thread based on thiefvictim relationships on the execution path, whereas the workloadsensitive algorithm selects appropriate tempo based on the size of workstealing deques. We construct HERMES on top of Intel Cilk Plus’s runtime, and implement tempo adjustment through standard Dynamic Voltage and Frequency Scaling (DVFS). Benchmarks running on HERMES demonstrate an average of 1112 % energy savings with an average of 34% performance loss through meterbased measurements over commercial CPUs. 1.
Expressing and Verifying Probabilistic Assertions
"... Traditional assertions express correctness properties that must hold on every program execution. However, many applications have probabilistic outcomes and consequently their correctness properties are also probabilistic (e.g., they identify faces in images, consume sensor data, or run on unreliabl ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
(Show Context)
Traditional assertions express correctness properties that must hold on every program execution. However, many applications have probabilistic outcomes and consequently their correctness properties are also probabilistic (e.g., they identify faces in images, consume sensor data, or run on unreliable hardware). Traditional assertions do not capture these correctness properties. This paper proposes that programmers express probabilistic correctness properties with probabilistic assertions and describes a new probabilistic evaluation approach to efficiently verify these assertions. Probabilistic assertions are Boolean expressions that express the probability that a property will be true in a given execution rather than asserting that the property must always be true. Given either specific inputs or distributions on the input space, probabilistic evaluation verifies probabilistic assertions by first performing distribution extraction to represent the program as a Bayesian network. Probabilistic evaluation then uses statistical properties to simplify this representation to efficiently compute assertion probabilities directly or with sampling. Our approach is a mix of both static and dynamic analysis: distribution extraction statically builds and optimizes the Bayesian network representation and sampling dynamically interprets this representation. We implement our approach in a tool called MAYHAP for C and C++ programs. We evaluate expressiveness, correctness, and performance of MAYHAP on programs that use sensors, perform approximate computation, and obfuscate data for privacy. Our case studies demonstrate that probabilistic assertions describe useful correctness properties and that MAYHAP efficiently verifies them. Categories and Subject Descriptors G.3 [Probability and Statis
ExpectationOriented Framework for Automating Approximate Programming
"... This paper describes ExpAX, a framework for automating approximate programming based on programmerspecified error expectations. Three components constitute ExpAX: (1) a programming model based on a new kind of program specification, which we refer to as expectations. Our programming model enable ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
This paper describes ExpAX, a framework for automating approximate programming based on programmerspecified error expectations. Three components constitute ExpAX: (1) a programming model based on a new kind of program specification, which we refer to as expectations. Our programming model enables programmers to implicitly relax the accuracy constraints without explicitly marking operations approximate; (2) a novel approximation safety analysis that automatically identifies a safetoapproximate subset of the program operations; and (3) an optimization that automatically marks a subset of the safetoapproximate operations as approximate while considering the error expectation. Further, we formulate the process of automatically marking operations as approximate as an optimization problem and provide a genetic algorithm to solve it. We evaluate ExpAX using a diverse set of applications and show that it can provide significant energy savings while improving the qualityofresult degradation. ExpAX automatically excludes the safetoapproximate operations that if approximated lead to significant quality degradation. 1.