物件導向軟體之架構(Object-Oriented Software Construction)探討

Approximate computing trades off computation quality with effort expended, and as rising performance demands confront plateauing resource budgets, approximate computing has become not merely attractive, but even imperative. In this article, we present a survey of techniques for approximate computing (AC). We discuss strategies for finding approximable program portions and monitoring output quality, techniques for using AC in different processing units (e.g., CPU, GPU, and FPGA), processor components, memory technologies, and so forth, as well as programming frameworks for AC. We classify these techniques based on several key characteristics to emphasize their similarities and differences. The aim of this article is to provide insights to researchers into working of AC techniques and inspire more efforts in this area to make AC the mainstream computing approach in future systems.

/pdf/a-survey-of-techniques-for-approximate-computing-3va5vv4jnf.pdf

A Survey of Techniques for Approximate Computing

The continued success of Deep Neural Networks (DNNs) in classification tasks has sparked a trend of accelerating their execution with specialized hardware. While published designs easily give an order of magnitude improvement over general-purpose hardware, few look beyond an initial implementation. This paper presents Minerva, a highly automated co-design approach across the algorithm, architecture, and circuit levels to optimize DNN hardware accelerators. Compared to an established fixed-point accelerator baseline, we show that fine-grained, heterogeneous datatype optimization reduces power by 1.5×; aggressive, inline predication and pruning of small activity values further reduces power by 2.0×; and active hardware fault detection coupled with domain-aware error mitigation eliminates an additional 2.7× through lowering SRAM voltages. Across five datasets, these optimizations provide a collective average of 8.1× power reduction over an accelerator baseline without compromising DNN model accuracy. Minerva enables highly accurate, ultra-low power DNN accelerators (in the range of tens of milliwatts), making it feasible to deploy DNNs in power-constrained IoT and mobile devices.

Minerva: enabling low-power, highly-accurate deep neural network accelerators

This paper describes a learning-based approach to the acceleration of approximate programs. We describe the \emph{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 low-power accelerator called a \emph{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 whole-application speedup of 2.3x and energy savings of 3.0x on average with quality loss of at most 9.6%.

/pdf/neural-acceleration-for-general-purpose-approximate-programs-chuxql7jbp.pdf

Neural Acceleration for General-Purpose Approximate Programs

Disciplined approximate programming lets programmers declare which parts of a program can be computed approximately and consequently at a lower energy cost. The compiler proves statically that all approximate computation is properly isolated from precise computation. The hardware is then free to selectively apply approximate storage and approximate computation with no need to perform dynamic correctness checks.In this paper, we propose an efficient mapping of disciplined approximate programming onto hardware. We describe an ISA extension that provides approximate operations and storage, which give the hardware freedom to save energy at the cost of accuracy. We then propose Truffle, a microarchitecture design that efficiently supports the ISA extensions. The basis of our design is dual-voltage operation, with a high voltage for precise operations and a low voltage for approximate operations. The key aspect of the microarchitecture is its dependence on the instruction stream to determine when to use the low voltage. We evaluate the power savings potential of in-order and out-of-order Truffle configurations and explore the resulting quality of service degradation. We evaluate several applications and demonstrate energy savings up to 43%.

/pdf/architecture-support-for-disciplined-approximate-programming-rnoarszkkg.pdf

Architecture support for disciplined approximate programming

Wavelet packet decompositions generalize the classical pyramidal wavelet structure. We use the vast amount of possible wavelet packet decomposition structures to create a secret wavelet domain and discuss how this idea can be used to improve the security of watermarking schemes. Two methods to create random wavelet packet trees are discussed and analyzed. The security against unauthorized detection is investigated. Using JPEG and JPEG2000 compression we assess the normalized correlation and Peak Signal to Noise Ratio (PSNR) behavior of the watermarks. We conclude that the proposed systems show improved robustness against compression and provide around 21046 possible keys. The security against unauthorized detection is greatly improved.

https://ece.uwaterloo.ca/~wdietl/publications/pubs/Dietl03c.pdf

Watermark Security via Secret Wavelet Packet Subband Structures

Scala combines the object-oriented and functional paradigms to an expressive programming language. It supports the creation of class hierarchies known from object-oriented languages like Java or C# and at the same time allows to model algebraic types through pattern matching, as found in many functional programming languages. The Universe type system applies the concept of ownership to Java-like languages and allows to control object modi cation and thereby maintain invariants. It does so by controlling aliasing without restricting it. This thesis presents an ownership type system for Scala and other Java-like programming languages. It combines support for type genericity with path-dependent types to extend the static expressiveness of the Universe type system.

/pdf/universe-type-system-for-scala-q0p3ccw320.pdf

Universe Type System for Scala

Ensuring computations are unit-wise consistent is an important task in software development. Numeric computations are usually performed with primitive types instead of abstract data types, which results in very weak static guarantees about correct usage and conversion of units. This paper presents PUnits, a pluggable type system for expressive units of measurement types and a precise, whole-program inference approach for these types. PUnits can be used in three modes: (1) modularly check the correctness of a program, (2) ensure a possible unit typing exists, and (3) annotate a program with units. Annotation mode allows human inspection and is essential since having a valid typing does not guarantee that the inferred specification expresses design intent. PUnits is the first units type system with this capability. Compared to prior work, PUnits strikes a novel balance between expressiveness, inference complexity, and annotation effort. We implement PUnits for Java and evaluate it by specifying the correct usage of frequently used JDK methods. We analyze 234k lines of code from eight open-source scientific computing projects with PUnits. We compare PUnits against an encapsulation-based units API (the javax.measure package) and discovered unit errors that the API failed to find. PUnits infers 90 scientific units for five of the projects and generates well-specified applications. The experiments show that PUnits is an effective, sound, and scalable alternative to using encapsulation-based units APIs, enabling Java developers to reap the performance benefits of using primitive types instead of abstract data types for unit-wise consistent scientific computations.

https://dl.acm.org/doi/pdf/10.1145/3428210

Precise inference of expressive units of measurement types

Ownership types and Universe types are two type systems used to structure the heap and enforce encapsulation disciplines. The parametricity of ownership types allows a finergrained description of heap topologies, whereas the flexibility of any references in Universe types allows sharing between data structures. No direct encoding of one type system in the other has been possible.Parametric ownership has recently been extended with existential quantification of contexts. We formalise such a language and give a formal translation between programs written in this language and using Universe types. We show that this translation is sound and complete.

/pdf/comparing-universes-and-existential-ownership-types-5byq0hh9gb.pdf

Comparing universes and existential ownership types

Object ownership is useful for many applications such as program verification, thread synchronization, and memory management. However, even lightweight ownership type systems impose considerable annotation overhead, which hampers their widespread application. This paper addresses this issue by presenting a tunable static type inference for Universe types. In contrast to classical type systems, ownership types have no single most general typing. Therefore, our inference is tunable: users can indicate a preference for certain typings by configuring heuristics through weights. A particularly effective way of tuning the static inference is to obtain these weights automatically through runtime ownership inference. We present how the constraints of the Universe type system can be encoded as a boolean satisfiability (SAT) problem, how the runtime ownership inference produces weights from program executions, and how a weighted Max-SAT solver finds a correct Universe typing that optimizes the weights. Our implementation provides the static and runtime inference tools as a set of commandline tools and Eclipse plug-ins, which we used to experiment with the proposed workflow and the quality of our inference.

/pdf/tunable-universe-type-inference-34j9juebgs.pdf

Werner Dietl

Papers

Watermark Security via Secret Wavelet Packet Subband Structures

Universe Type System for Scala

Precise inference of expressive units of measurement types

Comparing universes and existential ownership types

Tunable universe type inference