Results 1 - 10
of
15
Detecting software defects in telecom applications through lightweight static analysis: A war story
- Programming Languages and Systems: Proceedings of the Second Asian Symposium (APLAS’04), volume 3302 of LNCS
, 2004
"... Abstract. In safety-critical and high-reliability systems, software development and maintenance are costly endeavors. The cost can be reduced if software er-rors can be identied through automatic tools such as program analyzers and compile-time software checkers. To this effect, this paper describes ..."
Abstract
-
Cited by 20 (9 self)
- Add to MetaCart
(Show Context)
Abstract. In safety-critical and high-reliability systems, software development and maintenance are costly endeavors. The cost can be reduced if software er-rors can be identied through automatic tools such as program analyzers and compile-time software checkers. To this effect, this paper describes the architec-ture and implementation of a software tool that uses lightweight static analysis to detect discrepancies (i.e., software defects such as exception-raising code or hid-den failures) in large commercial telecom applications written in Erlang. Our tool, starting from virtual machine bytecode, discovers, tracks, and propagates type in-formation which is often implicit in Erlang programs, and reports warnings when a variety of type errors and other software discrepancies are identied. Since the analysis currently starts from bytecode, it is completely automatic and does not rely on any user annotations. Moreover, it is effective in identifying software de-fects even in cases where source code is not available, and more specically in legacy software which is often employed in high-reliability systems in operation, such as telecom switches. We have applied our tool to a handful of real-world applications, each consisting of several hundred thousand lines of code, and de-scribe our experiences and the effectiveness of our techniques.
Native code compilation of Erlang's bit syntax
, 2002
"... Erlang's bit syntax caters for flexible pattern matching on bit streams (objects known as binaries). Binaries are nowadays heavily used in typical Erlang applications such as protocol programming, which in turn has created a need for e#cient support of the basic operations on binaries. ..."
Abstract
-
Cited by 8 (3 self)
- Add to MetaCart
Erlang's bit syntax caters for flexible pattern matching on bit streams (objects known as binaries). Binaries are nowadays heavily used in typical Erlang applications such as protocol programming, which in turn has created a need for e#cient support of the basic operations on binaries.
Message analysis for concurrent programs using message passing
- ACM TOPLAS
, 2006
"... We describe an analysis-driven storage allocation scheme for concurrent systems that use message passing with copying semantics. The basic principle is that in such a system, data which is not part of any message does not need to be allocated in a shared data area. This allows for deallocation of th ..."
Abstract
-
Cited by 5 (2 self)
- Add to MetaCart
We describe an analysis-driven storage allocation scheme for concurrent systems that use message passing with copying semantics. The basic principle is that in such a system, data which is not part of any message does not need to be allocated in a shared data area. This allows for deallocation of thread-specific data without requiring global synchronization and often without even triggering garbage collection. On the other hand, data that is part of a message should preferably be allocated on a shared area, which allows for fast (O(1)) interprocess communication that does not require actual copying. In the context of a dynamically typed, higher-order, concurrent functional language, we present a static message analysis which guides the allocation. As shown by our performance evaluation, conducted using an industrial-strength language implementation, the analysis is effective enough to discover most data which is to be used as a message, and to allow the allocation scheme to combine the best performance characteristics of both a process-centric and a communal memory architecture.
Efficiently compiling a functional language on AMD64: the HiPE experience
- In PPDP ’05: Proceedings of the 7th ACM SIGPLAN international conference on Principles and practice of declarative programming
, 2005
"... We describe and document our experience from developing an AMD64 backend for the HiPE (High Performance Erlang) native code compiler. We consider implementation alternatives and critically examine design choices for obtaining an efficient AMD64 backend. In particular, we consider in detail how other ..."
Abstract
-
Cited by 5 (1 self)
- Add to MetaCart
(Show Context)
We describe and document our experience from developing an AMD64 backend for the HiPE (High Performance Erlang) native code compiler. We consider implementation alternatives and critically examine design choices for obtaining an efficient AMD64 backend. In particular, we consider in detail how other functional language implementors can migrate their existing x86 backends to the AMD64 architecture, a platform which is becoming increasingly important these days. We mention backend components that can be shared between x86 and AMD64, and those that better be different for achieving high performance on AMD64. Finally, we measure the performance of several different alternatives in the hope that this information can save development effort for others who intend to engage in a similar feat.
Unboxed compilation of floating point arithmetic in a dynamically typed language environment
- Implementation of Functional Languages: Proceedings of the 14th International Workshop, number 2670 in LNCS
, 2002
"... Abstract. In the context of the dynamically typed concurrent functional pro-gramming language ERLANG, we describe a simple static analysis for identifying variables containing floating point numbers, how this information is used by the BEAM compiler, and a scheme for efficient (just-in-time) compila ..."
Abstract
-
Cited by 4 (1 self)
- Add to MetaCart
(Show Context)
Abstract. In the context of the dynamically typed concurrent functional pro-gramming language ERLANG, we describe a simple static analysis for identifying variables containing floating point numbers, how this information is used by the BEAM compiler, and a scheme for efficient (just-in-time) compilation of floating point bytecode instructions to native code. The attractiveness of the scheme lies in its implementation simplicity. It has been fully incorporated in Erlang/OTP R9, and improves the performance of ERLANG programs manipulating floats consid-erably. We also show that by using this scheme, Erlang/OTP, despite being an implementation of a dynamically typed language, achieves performance which is competitive with that of state-of-the-art implementations of strongly typed strict functional languages on floating point intensive programs. 1
HILTI: An Abstract Execution Environment for Deep, Stateful Network Traffic Analysis
"... When developing networking systems such as firewalls, routers, and intrusion detection systems, one faces a striking gap between the ease with which one can often describe a desired analysis in high-level terms, and the tremendous amount of low-level imple-mentation details that one must still grapp ..."
Abstract
-
Cited by 2 (1 self)
- Add to MetaCart
(Show Context)
When developing networking systems such as firewalls, routers, and intrusion detection systems, one faces a striking gap between the ease with which one can often describe a desired analysis in high-level terms, and the tremendous amount of low-level imple-mentation details that one must still grapple with to come to a ro-bust solution. We present HILTI, a platform that bridges this divide by providing to application developers much of the low-level func-tionality, without tying it to a specific analysis structure. HILTI consists of two parts: (i) an abstract machine model that we tai-lor specifically to the networking domain, directly supporting the field’s common abstractions and idioms in its instruction set; and (ii) a compilation strategy for turning programs written for the ab-stract machine into optimized, natively executable code. We have developed a prototype of the HILTI compiler toolchain that fully implements the design’s functionality, and ported exemplars of net-working applications to the HILTI model to demonstrate the apt-ness of its abstractions. Our evaluation of HILTI’s functionality and performance confirms its potential to become a powerful plat-form for future application development.
A polyvariant type analysis for Erlang
- In preparation
"... Abstract. This paper presents a type analysis for the programming language Erlang. The analysis computes interprocedural control-flow and data-flow information, and should be applicable to any higher-order functional programming language with call-by-value semantics. The analysis uses a novel method ..."
Abstract
-
Cited by 1 (1 self)
- Add to MetaCart
(Show Context)
Abstract. This paper presents a type analysis for the programming language Erlang. The analysis computes interprocedural control-flow and data-flow information, and should be applicable to any higher-order functional programming language with call-by-value semantics. The analysis uses a novel method for polyvariance, static limiting, where an approximation of the call graph is analyzed to determine whether a function should be treated as polyvariant or monovariant. A general framework for polyvariant analysis is presented. This framework is used for experimental investigations to evaluate the cost and potential benefits of polyvariant analysis and to compare different approaches to polyvariant analysis. The experimental results show that static limiting gives the same or better precision as the other polyvariant analyses, while having more predictable analysis times. However, the experiments show only small improvements in precision for the various polyvariant analyses. 1
ErLLVM: An LLVM Backend for Erlang
"... This paper describes ErLLVM, a new backend for the HiPE com-piler, the native code compiler of Erlang/OTP, that targets the LLVM compiler infrastructure. Besides presenting the overall ar-chitecture of ErLLVM and its integration in Erlang/OTP, we de-scribe the changes to LLVM that ErLLVM required an ..."
Abstract
-
Cited by 1 (0 self)
- Add to MetaCart
(Show Context)
This paper describes ErLLVM, a new backend for the HiPE com-piler, the native code compiler of Erlang/OTP, that targets the LLVM compiler infrastructure. Besides presenting the overall ar-chitecture of ErLLVM and its integration in Erlang/OTP, we de-scribe the changes to LLVM that ErLLVM required and discuss technical challenges and decisions we took. Finally, we provide a detailed performance evaluation of ErLLVM compared to BEAM, the existing backends of the HiPE compiler, and Erjang.
BEAMJIT -A Just-in-Time Compiling Runtime for Erlang
"... Abstract BEAMJIT is a tracing just-in-time compiling runtime for the Erlang programming language. The core parts of BEAMJIT are synthesized from the C source code of BEAM, the reference Erlang abstract machine. The source code for BEAM's instructions is extracted automatically from BEAM's ..."
Abstract
- Add to MetaCart
(Show Context)
Abstract BEAMJIT is a tracing just-in-time compiling runtime for the Erlang programming language. The core parts of BEAMJIT are synthesized from the C source code of BEAM, the reference Erlang abstract machine. The source code for BEAM's instructions is extracted automatically from BEAM's emulator loop. A tracing version of the abstract machine, as well as a code generator are synthesized. BEAMJIT uses the LLVM toolkit for optimization and native code emission. The automatic synthesis process greatly reduces the amount of manual work required to maintain a just-in-time compiler as it automatically tracks the BEAM system. The performance is evaluated with HiPE's, the Erlang ahead-of-time native compiler, benchmark suite. For most benchmarks BEAMJIT delivers a performance improvement compared to BEAM, although in some cases, with known causes, it fails to deliver a performance boost. BEAMJIT does not yet match the performance of HiPE mainly because it does not yet implement Erlang specific optimizations such as boxing/unboxing elimination and a deep understanding of BIFs. Despite this BEAMJIT, for some benchmarks, reduces the runtime with up to 40%.
An AMD64 Backend for HiPE: Implementation, Performance Evaluation, and Lessons Learned
, 2004
"... This master’s thesis describes the construction of the AMD64 backend for the HiPE (High Performance Erlang) native code compiler, a part of Erlang’s primary implementation, the Erlang/OTP. More specifically it describes the work done when writing the compiler backend, some implementation choices tha ..."
Abstract
- Add to MetaCart
(Show Context)
This master’s thesis describes the construction of the AMD64 backend for the HiPE (High Performance Erlang) native code compiler, a part of Erlang’s primary implementation, the Erlang/OTP. More specifically it describes the work done when writing the compiler backend, some implementation choices that had to be made, and the performance effect of these choices. This thesis consists of two papers; the first describes the internals of the compiler backend, technical issues that had to be addressed in its development, and reports on its performance compared to the older HiPE backends and interpreted Erlang code. The second paper takes a deeper look at AMD64 backends in general, examines a few different implementation options and reports on their performance.
