Physical separation with class refinements and method refinements a la AHEAD and virtual separation using annotations a la #ifdef or CIDE are two competing implementation approaches for software product lines with com...
详细信息
ISBN:
(纸本)9781605584942
Physical separation with class refinements and method refinements a la AHEAD and virtual separation using annotations a la #ifdef or CIDE are two competing implementation approaches for software product lines with complementary advantages. Although both approaches have been mainly discussed in isolation, we strive for an integration to leverage the respective advantages. In this paper, we lay the foundation for such an integration by providing a model that supports both physical and virtual separation and by describing refactorings in both directions. We prove the refactorings complete, so every virtually separated product line can be automatically transformed into a physically separated one (replacing annotations by refinements) and vice versa. To demonstrate the feasibility of our approach, we have implemented the refactorings in our tool CIDE and conducted four case studies.
Consumer electronics today such as cell phones often have one or more low-power FPGAs to assist with energy-intensive operations in order to reduce overall energy consumption and increase battery life. However, curren...
详细信息
ISBN:
(纸本)9781450302036
Consumer electronics today such as cell phones often have one or more low-power FPGAs to assist with energy-intensive operations in order to reduce overall energy consumption and increase battery life. However, current techniques for programming FPGAs require people to be specially trained to do so. Ideally, software engineers can more readily take advantage of the benefits FPGAs offer by being able to program them using their existing skills, a common one being object-oriented programming. However, traditional techniques for compiling object-oriented languages are at odds with today's FPGA tools, which support neither pointers nor complex data structures. Open until now is the problem of compiling an object-oriented language to an FPGA in a way that harnesses this potential for huge energy savings. In this paper, we present a new compilation technique that feeds into an existing FPGA tool chain and produces FPGAs with up to almost an order of magnitude in energy savings compared to a low-power microprocessor while still retaining comparable performance and area usage.
For a language to be useful, it requires a robust and reliable implementation. Writing and maintaining such an implementation is a hard task, particularly for experimental or domain-specific language projects where re...
详细信息
Object-oriented programming is widely taught in introductory computer science courses, however no existing object-oriented programminglanguage is "the obvious choice" for a teaching language. This makes it ...
详细信息
This paper presents TransFinder, a compile-time tool that automatically determines which statements of an unsynchronized multithreaded program must be enclosed in atomic regions to enforce conflict-serializability. Un...
详细信息
ISBN:
(纸本)9781450302036
This paper presents TransFinder, a compile-time tool that automatically determines which statements of an unsynchronized multithreaded program must be enclosed in atomic regions to enforce conflict-serializability. Unlike previous tools, TransFinder requires no programmer input (beyond the program) and is more efficient in both time and space. Our implementation shows that the generated atomic regions range from being identical to, or smaller than, the programmer-specified transactions in the three Java Grande benchmarks considered, and in five of the eight STAMP benchmarks considered, while still providing identical synchronization semantics and results. The generated atomic regions are between 5 and 38 lines larger in the three remaining STAMP benchmarks. In the most conservative case, TransFinder can, based on the program structure, successfully identify and suggest an alternative that conforms exactly to the programmer-specified atomic regions. By generating small, highly-targeted, conflict-serializable atomic regions, TransFinder allows the programmer to focus further tuning efforts on only a small portion of the code (when further tuning is needed).
We present a novel approach to regular, multi-dimensional arrays in Haskell. The main highlights of our approach are that it (1) is purely functional, (2) supports reuse through shape polymorphism, (3) avoids unnecess...
详细信息
The functional programminglanguages Clean and Haskell have been around for over two decades. Over time, both languages have developed a large body of useful libraries and come with interesting language features. It i...
详细信息
ISBN:
(纸本)9781450302524
The functional programminglanguages Clean and Haskell have been around for over two decades. Over time, both languages have developed a large body of useful libraries and come with interesting language features. It is our primary goal to benefit from each other's evolutionary results by facilitating the exchange of sources between Clean and Haskell and study the forthcoming interactions between their distinct languages features. This is achieved by using the existing Clean compiler as starting point, and implementing a double-edged front end for this compiler: it supports both standard Clean 2.1 and (currently a large part of) standard Haskell 98. Moreover, it allows both languages to seamlessly use many of each other's language features that were alien to each other before. For instance, Haskell can now use uniqueness typing anywhere, and Clean can use newtypes efficiently. This has given birth to two new dialects of Clean and Haskell, dubbed Clean* and Haskell*. Additionally, measurements of the performance of the new compiler indicate that it is on par with the flagship Haskell compiler GHC.
For five years Intel's programming Systems Lab (PSL) has been collaborating with an external partner on a new functional programminglanguagedesigned for productivity on many-core processors. While the language i...
详细信息
ISBN:
(纸本)9781450305167
For five years Intel's programming Systems Lab (PSL) has been collaborating with an external partner on a new functional programminglanguagedesigned for productivity on many-core processors. While the language is not yet public, this talk outlines motivations behind the language and describes our experiences in implementing it using a variety of functional languages. The reference interpreter is written in Haskell and compiled with GHC while PSL's performance implementation is written in SML and compiled with Mlton. We have also generated Scheme code compiled with PLT Scheme as part of a prototyping effort. At several points, the project has had several contributors that did not have a background in functional languages working on the compiler and on writing benchmarks. We describe their experiences working in SML and with functional languages in general. Specifically: what they liked and disliked about using functional languages what was easy and hard about learning and using functional languages what worked/didn't work for helping them learn to program in functional languages which functional features they used and didn't use general observations about the code that they wrote what (if anything) they took away from the experience A design principle of the implementation effort was to by default avoid the use of imperative features. Previous experience and review of the literature suggested that many parts of a compiler could be written as well or better using primarily functional code, but that restricting ourselves entirely to the functional fragment of SML was probably not reasonable. We describe our experiences with this, and the tradeoffs that we encountered. Specifically: During the project we experimented with both immutable and mutable intermediate representations (IRs). We describe and motivate some of the scenarios where we used one or the other, explain our experiences with this, and describe cases where we feel that we made an inappropriate initial ch
The challenging nature of error handling constantly escalates as a growing number of environments consists of networked devices and software components. In these environments, errors cover a uniquely large spectrum of...
详细信息
ISBN:
(纸本)9781450302036
The challenging nature of error handling constantly escalates as a growing number of environments consists of networked devices and software components. In these environments, errors cover a uniquely large spectrum of situations related to each layer ranging from hardware to distributed platforms, to software components. Handling errors becomes a daunting task for programmers, whose outcome is unpredictable. Scaling up error handling requires to raise the level of abstraction beyond the code level and the try-catch construct, approaching error handling at the software architecture level. We propose a novel approach that relies on an Architecture Description language (ADL), which is extended with error-handling declarations. To further raise the level of abstraction, our approach revolves around a domain-specific architectural pattern commonly used in pervasive computing. Error handling is decomposed into components dedicated to platform-wide, error-recovery strategies. At the application level, descriptions of functional components include declarations dedicated to error handling. We have implemented a compiler for an ADL extended with error-handling declarations. It produces customized programming frameworks that drive and support the programming of error handling. Our approach has been validated with a variety of applications for building automation.
We propose to search for common abstractions for different concurrency models to enable high-level language virtual machines (VMs) to support a wide range of different concurrency models. This would enable domain-spec...
详细信息
ISBN:
(纸本)9781450302401
We propose to search for common abstractions for different concurrency models to enable high-level language virtual machines (VMs) to support a wide range of different concurrency models. This would enable domain-specific solutions for the concurrency problem. Knowledge about concurrency in the VM will most likely lead to better implementation opportunities on top of the different upcoming many-core architectures. The idea is to investigate the concepts of encapsulation and locality to this end. Thus, we are going to experiment with different language abstractions for concurrency on top of a VM, which supports encapsulation and locality, to see how languagedesigners could benefit, and how VMs could optimize programs using these concepts.
暂无评论