The arrival and popularity of multi-core processors have sparked a renewed interest in the development of parallel programs. Similarly, the availability of low-cost microprocessors and sensors has generated a great interest in embedded real-time programs. Ada is arguably the most appropriate language for development of parallel and real-time applications. Since it was first standardized in 1983, Ada's three major goals have remained:

• Program reliability and maintenance

• Programming as a human activity

• Efficiency

Meeting these goals has made Ada remarkably successful in the domain of mission-critical software. It is the language of choice for developing software for systems in which failure might result in the loss of life or property. The software in air traffic control systems, avionics, medical devices, railways, rockets, satellites, and secure data communications is frequently written in Ada. Ada has been supporting multiprocessor, multi-core, and multithreaded architectures as long as it has existed. We have nearly 30 years of experience in using Ada to deal with the problem of writing programs that run effectively on machines using more than one processor. While some have predicted it will be another decade before there is a programming model for multi-core systems, programmers have successfully used the Ada model for years. In February 2007, Karl Nyberg won the Sun Microsystems Open Performance Contest by building an elegant parallel Ada application (Nyberg, 2007). The parallel Ada code he wrote a decade earlier provided the foundation of this success.

In Chapter 7, we presented an overview of real-time scheduling theory. Those discussions were independent of any programming language. This chapter explains how to write real-time applications in Ada that are compliant with that scheduling theory. A compliant Ada program can be analyzed thereby increasing the application's reliability.

Ada practitioners have two international standards available for producing compliant Ada programs: Ada 2005 and POSIX 1003.1b. In order to apply real-time scheduling theory with these standards, we need some means to:

1. Implement periodic tasks. This implementation requires a way to represent time, a way to enforce periodic task release times, and a way to assign priorities to both tasks and shared resources.

2. Activate priority inheritance protocols for the shared resources.

3. And of course, select and apply a scheduler such as those presented in Chapter 7 (e.g. fixed priority scheduler or Earliest Deadline First).

The Ada 2005 and POSIX 1003.1b standards provide the means to create compliant programs through pragmas and specific packages. Real-time specific pragmas and packages for Ada 2005 are defined in Annex D of the Ada Reference Manual. The Ada binding POSIX 1003.5 provides the packages that allow us to create compliant real-time Ada programs using the POSIX standard.

The first six sections of this chapter discuss and use the packages and pragmas of Annex D. Section 8.1 shows how to express timing constraints of tasks with an Ada package called Ada.Real_Time.

Distribution is an important issue in software engineering, providing scalable systems across networks. Distribution supports a variety of new services from banking systems to social networks to video-on-demand. It is also used in embedded systems like cars and planes built with numerous interconnected computation-intensive blocks. When one processor is not enough, distribution is a natural complement to concurrency. In this chapter, we provide some of the elements to build a distributed system using Ada.

What are distributed systems?

Formally speaking, a distributed system is a federation of interconnected computers that collaborate to fulfill a task. As an example, one can cite web-based applications or constellations of satellites. Distributed systems rely on mechanisms to let information circulate from one node to another. In this section, we review key elements of distributed systems and discuss their strengths and limits.

Why distribute systems?

Before entering into the details of distribution and middleware, it is important to clarify the reasons why someone would want to build a distributed system. Distributing an application across several nodes requires an understanding of (1) the network (topology, technology, etc.), (2) its maintenance lifecycle (potential down time), and (3) its cost (performance and money). In addition, we need to be able to evaluate the value it adds to our application.

From an historic point of view (Vinoski, 2004), distribution was introduced in the early 1960s in large mainframe computer systems used for airline ticketing and banking.

In this chapter we will introduce you to the basic sequential features of the Ada programming language. You may find it useful to skim this chapter on first reading and then return to it when you encounter an unfamiliar language feature in later chapters. One chapter is not adequate to discuss all aspects of sequential programming with Ada. We discuss those that are most relevant to concurrent, embedded, and real-time programming and the examples used in this book. Barnes (2006) presents a comprehensive description of the Ada programming language. Ben-Ari (2009) does an excellent job describing the aspects of Ada relevant to software engineering. Dale et al. (2000) provide an introduction to Ada for novice programmers. You can find Ada implementations of the common data structures in Dale and McCormick (2007). There are also many Ada language resources available online that you may find useful while reading this chapter including English (2001), Riehle (2003), and Wikibooks (2010a). We will often refer you to the ARM, the Ada Reference Manual (Taft et al., 2006), which is available in both print and electronic forms.

DeRemer and Kron (1975) distinguished the activities of writing large programs from those of writing small programs. They considered large programs to be systems built from many small programs (modules), usually written by different people. It is common today to separate the features of a programming language along the same lines.

In Chapter 1 we demonstrated the effectiveness of concurrent algorithms. Together, Horace and Mildred can prepare a meal faster than one of them alone. The concurrent algorithm for controlling the process of chutney cooking provides a simpler and more reusable solution than the original sequential algorithm. Now that you have a basic understanding of sequential programming with Ada we are ready to create concurrent Ada programs.

Ada is a concurrent programming language — it provides the constructs needed to support the creation of programs with multiple threads of control. Ada's task is an implementation of Dijkstra's (1968) process. An Ada program is composed of one or more tasks that execute concurrently to solve a problem. In this chapter we examine the Ada task as an independent entity. In the next two chapters, we'll examine the facilities that allow tasks to communicate, synchronize, and share resources.

Defining tasks

As with packages, the definition of a task has two parts: a declaration and a body. We can define a task type from which we can create multiple tasks that execute the same sequence of statements. Alternatively, we can define a singleton task that ensures that only one task executes the sequence of statements in the body. Let's look at a program that illustrates both alternatives.

In the previous chapters, we introduced both Ada concurrency features (tasks, protected objects, and rendezvous) and advanced features to support real-time constructs (notion of priority, protocols to bound priority inversion, and task dispatching policies). Our Ada applications do not run alone. They execute within a run-time configuration. A run-time configuration consists of the processor that executes our application and the environment in which that application operates. This environment includes memory systems, input/output devices, and operating systems.

An important early design goal of Ada was to provide a compilation system that can create from one Ada program different executables that run in an equivalent way within a wide variety of run-time configurations. With little or no modifications to the Ada code, the same program should run on a variety of platforms — from small embedded platforms, such as those based on 8-bit micro-controllers and PDAs, to single processor microcomputers, multi-core processors, and multiprocessor systems. The run-time configuration may include no operating system; may include an RTOS (real-time operating system) like VxWorksTM, LynxOSTM, ORK+, MaRTE OS, and RTEMS; or may include a complete general purpose operating system such as Linux, WindowsTM, and Mac OSTM.

In this chapter, we detail how Ada concurrency constructs are supported by the Ada run-time environment. We first introduce a generic architecture for mapping Ada constructs onto an operating system. Then, we examine three different run-times for the open-source Ada compiler GNAT.

Chapter overview

This chapter provides a thorough discussion of the issues surrounding the optimization of linear systems. Section 7.2 describes fundamental properties, and presents a list of common linear transforms. Then, Section 7.3 formalizes the problem. Sections 7.4 and 7.5 introduce two important cases of linear system optimization, namely single- and multiple-constant multiplication. While the algorithms to solve these problems are important, they do not fully take advantage of the solution space; thus, they may lead to inferior results. Section 7.6 describes the relationship of these two problems to the linear system optimization problem and provides an overview of techniques used to optimize linear systems. Section 7.7 presents a transformation from a linear system into a set of polynomial expressions. The algorithms presented later in the chapter use this transformation during optimization. Section 7.8 describes an algorithm for optimizing expressions for synthesis using two-operand adders. The results in Section 7.9 describe the synthesis of high-speed FIR filters using this two-operand optimization along with other common techniques for FIR filter synthesis. Then, Section 7.10 focuses on more complex architectures, in particular, those using three-operand adders, and shows how CSAs can speed up the calculation of linear systems. Section 7.11 discusses how to consider timing constraints by modifying the previously presented optimization techniques. Specifically, the section describes ideas for performing delay aware optimization.

Chapter overview

This chapter provides a brief summary of the stages in the hardware synthesis design flow. It is designed to give unfamiliar readers a high-level understanding of the hardware design process. The material in subsequent chapters describes different hardware implementations of polynomial expressions and linear systems. Therefore, we feel that it is important, though not necessarily essential, to have an understanding of the hardware synthesis process.

The chapter starts with a high-level description of the hardware synthesis design flow. It then proceeds to discuss the various components of this design flow. These include the input system specification, the program representation, algorithmic optimizations, resource allocation, operation scheduling, and resource binding. The chapter concludes with a case study using an FIR filter. This provides a step-by-step example of the hardware synthesis process. Additionally, it gives insight into the hardware optimization techniques presented in the following chapters.

Hardware synthesis design flow

The initial stages of a hardware design flow are quite similar to the frontend of a software compiler. One of the biggest differences is that the input system specification languages are different. Hardware description languages must deal with many features that are unnecessary in software, which for the most part model execution in a serial fashion. Such features include the need to model concurrent execution of the underlying resources, define a variety of different data types specifically for different bit widths, and introduce some notion of time into the language.Figure 4.1 gives a high-level view of the different stages of hardware compilation.

Overview

Arithmetic is one of the old topics in computing. It dates back to the many early civilizations that used the abacus to perform arithmetic operations. The seventeenth and eighteenth centuries brought many advances with the invention of mechanical counting machines like the slide rule, Schickard's Calculating Clock, Leibniz's Stepped Reckoner, the Pascaline, and Babbage's Difference and Analytical Engines. The vacuum tube computers of the early twentieth century were the first programmable, digital, electronic, computing devices. The introduction of the integrated circuit in the 1950s heralded the present era where the complexity of computing resources is growing exponentially. Today's computers perform extremely advanced operations such as wireless communication and audio, image, and video processing, and are capable of performing over 1015 operations per second.

Owing to the fact that computer arithmetic is a well-studied field, it should come as no surprise that there are many books on the various subtopics of computer arithmetic. This book provides a focused view on the optimization of polynomial functions and linear systems. The book discusses optimizations that are applicable to both software and hardware design flows; e.g., it describes the best way to implement arithmetic operations when your target computational device is a digital signal processor (DSP), a field programmable gate array (FPGA) or an application specific integrated circuit (ASIC).

Polynomials are among the most important functions in mathematics and are used in algebraic number theory, geometry, and applied analysis.

Chapter overview

To further motivate the techniques described in this book, we demonstrate the situations in which they are useful and the manner in which they fit into the design flow. Arithmetic optimizations are applicable when writing software as well as during the design of hardware components. This chapter gives a high-level overview of the software compilation process. We start by describing the basic structure of a modern compiler. Then we provide more detail about the compilation process including the place where arithmetic optimizations can be implemented. Finally, we describe the algebraic transformations that are used in current compilers. These include dataflow optimization, CSE, value numbering, loop invariant code motion, partial redundancy elimination (PRE), operator strength reduction, and the Horner form.

Basic software compiler structure

A compiler is used to reduce the complexity of designing digital systems. Quite simply, it transforms an input specification written in some high-level language into another language which is almost always at a lower level of abstraction. Perhaps the most common example is a software compiler, which takes source code written in some high-level programming language (e.g., C/C++, Java) into object code specified by an assembly or machine language for programming a microprocessor (e.g., Intel x86, SPARC, MIPS).

A compiler provides several benefits including:

1. (1) Raising the level of abstraction to allow the programmer to reason about the problem in a high-level language, which is often more efficient.

2. (2) Performing trivial and/or tedious transformations, e.g., converting assembly code into binary code.

3. (3) Finding obvious semantic and syntactic mistakes in the specification.

4. […]

Chapter overview

Polynomial expressions and linear systems are found in a wide range of applications: perhaps most fundamentally, Taylor's theorem states that any differentiable function can be approximated by a polynomial. Polynomial approximations are used extensively in computer graphics to model geometric objects. Many of the fundamental digital signal processing transformations are modeled as linear systems, including FIR filters, DCT and H.264 video compression. Cryptographic systems, in particular, those that perform exponentiation during public key encryption, are amenable to modeling using polynomial expressions. Finally, address calculation during data intensive applications requires a number of add and multiply operations that grows larger as the size and dimension of the array increases. This chapter describes these and other applications that require arithmetic computation. We show that polynomial expressions and linear systems are found in a variety of applications that are driving the embedded systems and high-performance computing markets.

Approximation algorithms

Polynomial functions can be used to approximate any differentiable function. Given a set of points, the unisolvence theorem states that there always exists a unique polynomial, which precisely models these points. This is extremely useful for computing complex functions such as logarithm and trigonometric functions and forms the basis for algorithms in numerical quadrature and numerical ordinary differential equations. More precisely, the unisolvence theorem states that, given a set of n + 1 unique data points, a unique polynomial with degree n or less exists.

The purpose of the book is to provide an understanding of the design methodologies and optimizations behind the hardware synthesis and software optimization of arithmetic functions. While we have provided a discussion on the fundamentals of software compilation, hardware synthesis and digital arithmetic, much of the material focuses on the implementation of linear systems and polynomial functions in hardware or software. It is therefore intended for students and researchers with a solid background in computing systems.

The three of us started looking into this topic in 2003, back when Anup was a graduate student of Ryan's at the University of California, Santa Barbara; Farzan was a researcher at Fujitsu at that time. Our initial research focused on the optimizations of polynomial functions, attempting to understand the optimal method for synthesizing these as a digital circuit. While developing the model for this synthesis process, we noticed that this same model could be used to describe linear systems. Therefore, the algorithms we developed to optimize polynomials were applicable to linear systems as well. Around this time we received additional funding from the UC Discovery grant and Fujitsu to further study these optimizations. The resulting research was published as numerous journal, conference and workshop papers, and was a basis for Anup's Ph. D. thesis. We noticed the significant lack of published material in this topic area and approached Cambridge University Press with the idea of writing a book on the topic; the obvious result of this lies in the following pages.