A New Abstract Domain for the Representation of Mathematically Equivalent Expressions

Ioualalen, Arnault; Martel, Matthieu

doi:10.1007/978-3-642-33125-1_8

Cited by 25 publications

(32 citation statements)

References 16 publications

(15 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We conclude that the compiler is probably the wrong place to perform aggressive program transformations over FP operations, because it lacks much of the information necessary for this endeavor. Automatic code generation tools, however, are in a more favorable position to preserve or improve precision by reassociation and other aggressive transformations [30].…”

Section: Discussionmentioning

confidence: 99%

A Formally-Verified C Compiler Supporting Floating-Point Arithmetic

Boldo

Jourdan²,

Leroy³

et al. 2013

2013 IEEE 21st Symposium on Computer Arithmetic

View full text Add to dashboard Cite

Abstract-Floating-point arithmetic is known to be tricky: roundings, formats, exceptional values. The IEEE-754 standard was a push towards straightening the field and made formal reasoning about floating-point computations possible. Unfortunately, this is not sufficient to guarantee the final result of a program, as several other actors are involved: programming language, compiler, architecture. The CompCert formally-verified compiler provides a solution to this problem: this compiler comes with a mathematical specification of the semantics of its source language (ISO C90) and target platforms (ARM, PowerPC, x86-SSE2), and with a proof that compilation preserves semantics. In this paper, we report on our recent success in formally specifying and proving correct CompCert's compilation of floating-point arithmetic. Since CompCert is verified using the Coq proof assistant, this effort required a suitable Coq formalization of the IEEE-754 standard; we extended the Flocq library for this purpose. As a result, we obtain the first formally verified compiler that provably preserves the semantics of floating-point programs.

show abstract

Section: Discussionmentioning

confidence: 99%

A Formally-Verified C Compiler Supporting Floating-Point Arithmetic

Boldo

Jourdan²,

Leroy³

et al. 2013

2013 IEEE 21st Symposium on Computer Arithmetic

View full text Add to dashboard Cite

show abstract

“…To our knowledge, the only work that considers rewriting of expressions to improve precision in the context of abstract interpretation is [11]. The authors develop an abstract domain for representing an under-approximation of mathematically equivalent expressions.…”

Section: Related Workmentioning

confidence: 99%

“…Consider a fixed-point implementation of this controller. If we assume an input range of [−10, 10] for all input variables and a uniform bit length of 16, each input variable gets assigned the fixed-point format 1,16,11 . This means that of the 16 bits we use 1 bit to represent the sign of the number, 4 bits for the integer part (10 < 2 4 = 16), and the remaining 11 bits for the fractional part.…”

Section: Examplementioning

confidence: 99%

Synthesis of fixed-point programs

Darulová

Kunčak

Majumdar

et al. 2013

2013 Proceedings of the International Conference on Embedded Software (EMSOFT)

View full text Add to dashboard Cite

Several problems in the implementations of control systems, signal-processing systems, and scientific computing systems reduce to compiling a polynomial expression over the reals into an imperative program using fixed-point arithmetic. Fixed-point arithmetic only approximates real values, and its operators do not have the fundamental properties of real arithmetic, such as associativity. Consequently, a naive compilation process can yield a program that significantly deviates from the real polynomial, whereas a different order of evaluation can result in a program that is close to the real value on all inputs in its domain.We present a compilation scheme for real-valued arithmetic expressions to fixed-point arithmetic programs. Given a real-valued polynomial expression t, we find an expression t that is equivalent to t over the reals, but whose implementation as a series of fixed-point operations minimizes the error between the fixed-point value and the value of t over the space of all inputs. We show that the corresponding decision problem, checking whether there is an implementation t of t whose error is less than a given constant, is NP-hard. We then propose a solution technique based on genetic programming. Our technique evaluates the fitness of each candidate program using a static analysis based on affine arithmetic. We show that our tool can significantly reduce the error in the fixed-point implementation on a set of linear control system benchmarks. For example, our tool found implementations whose errors are only one half of the errors in the original fixed-point expressions.

show abstract

“…When an expansion algorithm finds a homogeneous part it inserts a polynomial number of abstraction boxes into it, each of these abstraction boxes representing alternative versions of the homogeneous part. We have designed several polynomial algorithms to build APEG, described in [8] III. PROFITABILITY ANALYSIS To compute safe bounds on the numerical accuracy of arithmetic expressions, we use abstract values (…”

Section: Apeg Constructionmentioning

confidence: 99%

“…Our approach is based on abstract interpretation [5]. We build Abstract Program Equivalence Graphs (APEGs) to represent in polynomial size an exponential number of mathematically equivalent expressions [8]. APEGs are abstractions of the Equivalence Program Expression Graphs introduced in [14].…”

Section: Introductionmentioning

confidence: 99%

Synthesizing accurate floating-point formulas

Ioualalen

Martel

2013

2013 IEEE 24th International Conference on Application-Specific Systems, Architectures and Processors

Self Cite

View full text Add to dashboard Cite

Abstract-Many critical embedded systems perform floatingpoint computations yet their accuracy is difficult to assert and strongly depends on how formulas are written in programs. In this article, we focus on the synthesis of accurate formulas mathematically equal to the original formulas occurring in source codes. In general, an expression may be rewritten in many ways. To avoid any combinatorial explosion, we use an intermediate representation, called APEG, enabling us to represent many equivalent expressions in the same structure. In this article, we specifically address the problem of selecting an accurate formula among all the expressions of an APEG. To validate our approach, we present experimental results showing how APEGs, combined with profitability analysis, make it possible to significantly improve the accuracy of floating-point computations.

show abstract

A New Abstract Domain for the Representation of Mathematically Equivalent Expressions

Cited by 25 publications

References 16 publications

A Formally-Verified C Compiler Supporting Floating-Point Arithmetic

A Formally-Verified C Compiler Supporting Floating-Point Arithmetic

Synthesis of fixed-point programs

Synthesizing accurate floating-point formulas

Contact Info

Product

Resources

About