Amake: Cached Builds of Top-Level Targets

This paper describes a software-build tool named Amake, an extension of GNU Make. Its additional features solve important problems that have, until now, only been addressed by “high-end” build tools (e.g., ClearCase and Vesta). With a typical build tool, if a top-level target must be updated, intermediate targets must be built from sources, and then combined to build the top-level target. The enhancements described here allow a top-level target to be fetched from a shared cache, without building, or even fetching its intermediate-target dependencies. Thus, a developer’s workspace may need only contain sources and top-level targets. This reduces build time, reduces network traffic, and saves disk space

Ant Build Maintenance with Formiga

A build system produces a set of deliverables from a software project\u27s source code and resources. Build maintenance refers to the changes made to the build system as a software project evolves over time. It has been shown to impose a significant overhead on overall development costs, in part because changes to source code often require parallel changes in the build system. However, little tool support exists to assist developers with build maintenance, particularly for those changes that must accompany changes to the source code. Formiga is a build maintenance and dependency discovery tool for the Ant build system. Formiga\u27s primary uses are to automate build changes as the source code is updated, to identify the build dependencies within a software project, and to assist with build refactoring. Formiga is implemented as an IDE plugin, which allows it to recognize when project resources are updated and automatically update the build system accordingly. This implementation also allows it to leverage existing metaphors used by developers to maintain source code, thus making it easier to use. A controlled experiment was conducted to assess Formiga\u27s ability to assist developers with build maintenance. Formiga was shown to signficantly reduce the time required to perform build maintenance while increasing the correctness with which it can be performed

Linux kernel support for Micro-Heterogeneous Computing

Heterogeneous Computing (HC) is a technique speeds the computation of large tasks by utilizing multiple computers or supercomputers, each of which is best suited to a particular type of computation. Micro-Heterogeneous Computing (MHC) has been proposed to bring this practice to individual computers. With the aid of the higher speed, short distance interconnects found within the next generation of personal computers and commodity servers, it should be possible to apply HC to relatively small grain sizes. MHC draws on the observations that in order for a new computing technology to become widely accepted, and cost effective, there must be a suitable abstraction layer that frees the application writers from the need of precise technical knowledge about the system. MHC provides such an abstraction layer, referred to as the MHC framework, which provides automated solutions to many of the problems that must be overcome when utilizing HC. The framework was designed with the goals of user transparency, flexibility, and performance. The problems addressed include matching tasks to devices and scheduling them (collectively known as mapping), dependency analysis, and parallelization of serial code. All of these problems are solved dynamically at run time by the framework whose implementation is discussed herein. In support of this framework, this thesis specifies a format for libraries that provide common functions and free their users from the tasks of code profiling and analytical benchmarking. This thesis provides the first implementation for such an abstraction layer by utilizing the Linux operating system. This thesis provides not only the kernel level support necessary to schedule tasks to hardware, but also implements the entire core framework, with functioning solutions to the problems mentioned above. This thesis provides well-defined interfaces and methods to expand the MHC system with new scheduling heuristics, function libraries, and device drivers

Adding Automatic Dependency Processing to Makefile-Based Build Systems with Amake

This paper explains how to improve the quality of an existing Makefile-based build system, using a new variant of Make. Ordinary file-oriented dependencies are detected, recorded, and monitored automatically. Checksums are compared, rather than timestamps. Other important dependencies are also processed automatically. This provides an accurate, compact, and low-maintenance build system. Experiences with the Linux kernel/driver build system are described