A Practical Introduction to Computer Architecture by Daniel Page.
The book in PDF Format with title A Practical Introduction to Computer Architecture by Daniel Page is available to download for free and Download Link is at the end of the article
Part I Tools and Techniques
1 Mathematical Preliminaries
2 Basics of Digital Logic
3 Hardware Design Using Verilog
Part II Processor Design
4 A Historical and Functional Perspective
5 Basic Processor Design
6 Measuring Performance
7 Arithmetic and Logic
8 Memory and Storage
9 Advanced Processor Design
Part III The Hardware/Software Interface
10 Linkers and Assemblers
12 Operating Systems
13 Efficient Programming
Part IV Appendices
SPIM: A MIPS32 Simulator
Foreword: It is a great pleasure to write a preface to this book. In my view, the content is unique in that it blends traditional teaching approaches with the use of mathematics and a mainstream Hardware Design Language (HDL) as formalisms to describe key concepts. The book keeps the “machine” separate from the “application” by strictly following a bottom-up approach: it starts with transistors and logic gates and only introduces assembly language programs once their execution by a processor is clearly defined.
Using a HDL, Verilog in this case, rather than static circuit diagrams is a big deviation from traditional books on computer architecture. Static circuit diagrams cannot be explored in a hands-on way like the corresponding Verilog model can. In order to understand why I consider this shift so important, one must consider how computer architecture, a subject that has been studied for more than 50 years, has evolved.
In the pioneering days computers were constructed by hand. An entire computer could (just about) be described by drawing a circuit diagram. Initially, such diagrams consisted mostly of analogue components before later moving toward digital logic gates. The advent of digital electronics led to more complex cells, such as half-adders, flip-flops, and decoders being recognised as useful building blocks. However, miniaturisation of devices and hence computers has led to the design of single circuits containing millions or even billions of components. As a result, handlay-out is only used for specific modules, and circuit diagrams are less useful as a mechanism for describing functionality for real circuits.
Instead, two formalisms are used in industry: HDLs and mathematics. A HDL allows us to tell the component-layout and simulation tools how we would like to implement our circuit; mathematics tells us what the circuit ought to do. In order to verify whether the circuit does what we want it to, we can (partly mechanically) compare the mathematical description with the HDL description. This represents increased use of abstraction to cope with complexity, and an engineer can now be productive by simply understanding and using high-level circuit design (e.g., multiplier design or pipelined processors) and formalisms (e.g., HDLs and mathematics).
Circuit diagrams are still used in the design flow, but mostly to sketch the physical layout, in order to predict whether a circuit can be laid out sensibly.
Dealing with gaps in understanding between such a wide range of concepts and techniques is often off-putting for people new to the subject. The best way to approach the problem is by placing it within a practical context that enables students to experiment with ideas and discover themselves the advantages and disadvantages of a particular technique.
In this book, Dan does just that by giving an excellent overview of key concepts and an introduction to formalisms with which they can be explored. I hope this book will inspire many readers to follow a career in this fascinating subject.
Principal Technologist, XMOS.
In my (limited) experience, and although there are a number of genuinely excellent textbooks on the subject, two main challenges exist in relation to delivery of University level taught modules in computer architecture:
1. Such modules are often regarded as unpopular and irrelevant by students who have not been exposed to the subject before, and who view a computer system from the applications level. This is compounded by the prevalence of technologies such as Java which place a further layer between the student and actual computer hardware. In short, and no matter how one tries to persuade them otherwise, students often see no point in learning about the internals of a computer system because they cannot see the benefit.
2. Conventional textbooks teach the subject in a different way than in other modules students are exposed to at the same time. For example, conventional wisdom says that one cannot “teach” programming, one has to “do” programming in order to learn. This is in stark contrast to textbooks on computer architecture where students are often forced to learn in a more theoretical way, learning by taking facts for granted rather than experimenting to arrive at their own conclusions. For example, because of the difficulty in working with large logic designs on paper, any practical work is often limited and hence detached from the more challenging content.
I would argue that this is a shame: computer architecture represents a broad spectrum of fundamental and exciting topics that underpin computer science in general. Aside from the technical challenges and sense of achievement that stem from understanding exactly how high-level programs are actually executed on devices built from simple building blocks, historical developments in computer architecture neatly capture and explain many design decisions that have shaped a landscape we now take for granted. The representation of strings in C is a great example: the nullterminated ASCIIZ approach was not adopted for any real reason other than the PDP-7 computer included instructions ideal for processing strings in this form, and yet we still live with this decision years after the PDP-7 became obsolete. Seemingly frivolous anecdotes and examples like this are increasingly being consigned to history whereas from an Engineering perspective, one would like to learn and understand previous approaches so as to potentially improve in the future.
International experts regularly debate tools and techniques for delivering University-level modules in computer architecture; the Workshop on Computer Architecture Education (WCAE), currently held in conjunction with the International Symposium on Computer Architecture (ISCA), is the premier research conference in this area. This book represents an attempt at translating my personal philosophy, that theoretical concepts should be accessible for practical experimentation, into a form suitable for use in such modules. Put simply, I see computer architecture as a subject in which “getting things done” is paramount; the ability to understand tradeoffs before selecting between and implementing well considered design options is often as important as the study of those options at a more theoretical level. This focus is underlined by the book sub-title: a “practical” approach is the aim throughout. To enable this, a key feature of this book is inclusion and use of a hardware description language (i.e., Verilog), and a concrete processor (i.e., MIPS32) as practical vehicles for modelling and experimenting with digital logic and processor design.
The content is organised into three parts which contain a total of thirteen core chapters. Although some slight disagreement about inclusion of specific topics is inevitable, the chapters represent a compromise between my informal opinion, interests and experience, and more formal curriculum guidelines such as that developed by the UK Quality Assurance Agency (QAA): http://www.qaa.ac.uk/ Of course, international equivalents exist; examples include those developed jointly by the IEEE and ACM, leading professional bodies within this domain:
http://www.computer.org/curriculum/ The general aim of this book is to cover topics every computer science student should have at least a basic grasp of, and equip said students with enough knowledge to read and understand more advanced textbooks. In this respect, the core target audience is first-year Undergraduate students with a rudimentary knowledge of programming in C. More generally, the book content is pitched at a level which satisfies most of the demands that have resulted from our degree programmes at the University of Bristol. In particular, the more advanced material has proved useful as a bridge toward, or in support of, more specialised textbooks that cover later-year Undergraduate and Postgraduate modules.
The book chapters are described briefly below. Very roughly the three parts of the book can be viewed as somewhat self-contained, representing three layers or levels of abstraction: the digital logic layer, the instruction set and micro-architecture layer, and the hardware/software interface. Part 1 deals with basic tools and techniques which underpin the rest of the book:
Chapter 1 Introduces the theoretical background including logic, sets, and number representation.
Chapter 2 Uses the theory developed in the previous chapter to describe the basics of digital logic including logic gates and their construction using transistors, combinatorial and clocked circuits and their optimisation.
Chapter 3 As a means of realising the digital logic designs presented in the previous chapter, Verilog is presented in an introductory manner; this content is written with a reader who is a proficient C programmer in mind.
Part 2 deals with the broad topic of processor design and implementation. The content takes a step-by-step approach, starting with a functional description of a computer processor and gradually expanding on the details, issues and techniques that have resulted in modern, high-performance processor designs: Chapter 4 The first step in introducing the design of processors (as an extension to the study of general circuits) is to track historical developments and use them as a means to explain central concepts such as the fetch-decode-execute cycle.
Chapter 5 Once the core concepts are introduced, a concrete realisation in the form of MIPS32 is discussed; this discussion includes details such as addressing modes and instruction encoding for example.
Chapter 6 This chapter outlines some basic methods for evaluating processors in terms of various metrics which can be used to defined quality, focusing on performance in particular.
Chapter 7 As a vital component in any processor, the design of efficient circuits for arithmetic (e.g., addition and multiplication) is introduced and demonstrated using Verilog.
Chapter 8 In the same way as arithmetic, the design of efficient components in the memory hierarchy is introduced and demonstrated using Verilog.
Chapter 9 Finally, a number of more advanced topics in processor design are investigated including approaches such as superscalar and vector processors.
Finally, Part 3 attempts to bridge the gap between hardware and software by examining the programming tools and operating system concepts that support the development and execution of programs:
Chapter 10 As a first step, this chapter presents a detailed description of a development tool-chain, starting with linkers and assemblers. This material is supported by and links to Appendix A, which provides a stand-alone tutorial on using SPIM, a MIPS32 simulator. As such, it provides a concrete means of writing
programs for the processor design introduced earlier in the book.
Chapter 11 Following the previous chapter, compilers are now introduced by focusing on their aspects which are most closely tied to the processor they target. For example, register allocation, instruction select and scheduling are all covered.
Chapter 12 With a means of writing programs established, the operating system layer is introduced in a practical way by using SPIM as a platform for real implementations of concepts such as scheduling and interrupt handling.
Chapter 13 Finally, a somewhat novel chapter examines the concept of efficient programming. This is written from the point of view of a programmer who wants (or needs) to capitalise on the behaviour and characteristics of the concepts presented in previous chapters to improve their programs.
Each chapter concludes with a set of example questions which are largely at a level one might encounter in a degree-level examination. These questions are numbered consecutively (rather than relative to the chapter number) and a set of example solutions can be found in Appendix B.
Although this content might clearly contain accidental omissions, some topics have been avoided by design. Optimistically, one might view them as ideal for inclusion in future versions of the book; more realistically they represent topics that are important but not vital at the level the book is aimed at:
• Perhaps the largest omission, at least the one which seems likely to prompt the loudest outcry, is that of floating point arithmetic. Although the book covers floating point representation briefly, the circuits for arithmetic and instruction sets that use them are integer only. The rationale for this decision was purely space: floating point represents a fairly self-contained topic which could be left out without too negative an impact on core topics covered by the rest of the content.
• A similar situation exists with the topic of design verification: although testing the digital logic designs one can produce with Verilog is important, one could easily dedicate an entire book to the art of good design verification.
• The main emphasis of the book is processors and as such, they are examined somewhat in isolation. This contrasts with reality where such processors typically form part of a larger system including peripherals, communication networks and so on. As such, the broad topic of system-level design, which is central to other books, is not covered here.
• At the time of writing, the “hot topic” in computer architecture is the advent of multi-core devices, i.e., many processors on a single chip. Although this has been a research area for many years in an attempt to cope with design complexity and effective use of increased transistor counts, commodity multi-core devices have breathed new life into the subject. Again, because the emphasis is more intraprocessor than inter-processor, we omit the topic here although among all the options for future material this is perhaps the most compelling.
• The book covers only traditional logic styles. However, for specific application areas it has become attractive to investigate alternatives; the idea is basically that one should be aware of available alternatives and use the right one in the right place. Specifically, secure logic styles (which help to prevent certain types of passive attack) and asynchronous logic (which avoids the need for global clock signals) represent interesting avenues for future content. Contact As people who know me will (too) willingly attest, I am far from perfect. As a result, this book is sure to include problems in the shape of minor errors and mistakes. If you find such a problem, or have a more general comment, I would be glad to hear about it; you can contact me via http://www.cs.bris.ac.uk/home/page/
A Practical Introduction to Computer Architecture by Daniel Page pdf.
⏩Author: Daniel Page
⏩Publisher: Springer; 2009 edition (May 29, 2009)
⏩Puplication Date: May 29, 2009
⏩Size: 9.85 MB
Download A Practical Introduction to Computer Architecture by Daniel Page in pdf format for free.