Muutke küpsiste eelistusi

Alpha Risc Architecture for Programmers [Pehme köide]

  • Formaat: Paperback / softback, 400 pages, kõrgus x laius x paksus: 240x180x35 mm, kaal: 1046 g
  • Ilmumisaeg: 12-Nov-1998
  • Kirjastus: Prentice Hall
  • ISBN-10: 0130814385
  • ISBN-13: 9780130814388
  • Pehme köide
  • Hind: 74,79 €*
  • * saadame teile pakkumise kasutatud raamatule, mille hind võib erineda kodulehel olevast hinnast
  • See raamat on trükist otsas, kuid me saadame teile pakkumise kasutatud raamatule.
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Lisa soovinimekirja
  • Formaat: Paperback / softback, 400 pages, kõrgus x laius x paksus: 240x180x35 mm, kaal: 1046 g
  • Ilmumisaeg: 12-Nov-1998
  • Kirjastus: Prentice Hall
  • ISBN-10: 0130814385
  • ISBN-13: 9780130814388
8143H-4 The practical guide to computer architecture - based on Alpha, the world's #1 64-bit processor. With Alpha RISC Architecture for Programmers, you can master the fundamentals of computer architecture and assembly language programming in the context of one of the world's most advanced high-performance processors: the 64-bit Alpha. The book introduces assemblers, debuggers, instruction formats, addressing, branch instructions, logical operations, and many other key fundamentals of processor architecture. It delivers real-world guidance for solving practical programming problems - along with extensive runnable sample code.Coverage includes: *Working with bytes in a load/store architecture *Subroutines, procedures, and floating-point operations *Conditional assembly and macros *Text I/O, including UNIX and OpenVMS implementations *Run-time environment support for both high-level and low-level languages *Writing subprograms and linking higher-level modules with assembly language modules Learn how processor architecture impacts performance, including the roles of instruction size, addressing mode, instruction power, program size, in-line functions, recursion, pipelining, compilers, and post-compilation optimization. Master essential debugging techniques and review the latest features of the Alpha architecture, including the Motion Video Extension and Privileged Architecture Library. The book includes extensive references to Alpha resources for Windows NT, UNIX, and OpenVMS. It will be an invaluable resource for hardware engineers, programmers, and students alike.
Preface xiii(4)
Trademarks xvii
Chapter 1 Architecture and Implementation
1(18)
Analogy: Piano Architecture
2(1)
Types of Computer Languages
3(1)
Why Study Assembly Language?
4(1)
The Alpha and its Ancestors in a Superfamily
5(2)
SQUARES: A Comparative Programming Example
7(5)
Review of Number Systems
12(5)
Positional Coefficients and Weights
12(1)
Binary and Hexadecimal Representations
13(2)
Signed Integers
15(2)
Bibliography
17(1)
Exercises
17(2)
Chapter 2 Computer Structures and the Alpha
19(24)
Computer Structures
19(5)
The Central Processing Unit
20(1)
The Memory
21(3)
The Input/Output System
24(1)
Instruction Execution
24(3)
Classes of Instruction Architectures
27(2)
Introduction to the Alpha
29(1)
Alpha Information Units and Data Types
30(9)
Integers
32(1)
Floating-Point Numbers
33(3)
Alphanumeric Characters
36(3)
Summary
39(1)
Bibliography
39(1)
Exercises
39(4)
Chapter 3 The Program Assembler and Debugger
43(36)
Program Development Steps
44(4)
SQUARES2: A Variant Example
48(2)
Assembler Statement Types
50(4)
Statement Format
50(1)
Symbolic Addresses
51(1)
Classes of Alpha Assembly Language Operators
52(2)
The Functions of a Symbolic Assembler
54(10)
Constants
54(2)
Symbols or Identifiers
56(1)
Storage Allocation
56(2)
The Location Counter
58(2)
Expressions
60(1)
Control Statements
61(1)
Elements of a Listing File
62(2)
The Assembly Process
64(1)
The Linking Process
65(3)
The Program Debugger
68(6)
Capabilities of Debugger Programs
68(3)
Running SQUARES2 using dbx (Unix)
71(1)
Running SQUARES2 using the Open VMS Debugger
72(1)
Examples of Debugger Commands
73(1)
Tracepoint example
73(1)
Watchpoint example
73(1)
Using the screen mode (Open VMS)
74(1)
Comparing Variants of a Source File
74(1)
Conventions for Writing Programs
75(1)
Summary
76(1)
Bibliography
77(1)
Exercises
77(2)
Chapter 4 Alpha Instruction Formats and Addressing
79(34)
Overview of Alpha Instruction Formats
81(2)
Integer Arithmetic Instructions
83(4)
Addition, Subtraction, and Multiplication
83(3)
Arithmetic Overflow
86(1)
Extended Precision Multiplication
86(1)
What About Division?
87(1)
Introduction to Addressing Modes
87(3)
Literal Addressing
87(1)
Direct Addressing
88(1)
Indirect Addressing
88(1)
Displacement Addressing
88(2)
Summary of Alpha Addressing Modes
90(1)
RADIX: Using Arithmetic Instructions
90(3)
Integer Load and Store Instructions
93(8)
Load Address Instructions
93(2)
Non-addressing Uses of Load Address Instructions
95(1)
Load and Store Operations
96(2)
Addressing Details in the RADIX Program
98(1)
Unix Addressing
98(2)
Open VMS Addressing
100(1)
Accessing Simple Record Structures Using Displacements
101(1)
DOT 3: Using Load and Store Instructions
102(3)
Addressing Modes in Other Architectures
105(3)
Scaled Addition and Subtraction Instructions
108(1)
Summary
109(1)
Bibliography
109(1)
Exercises
110(3)
Chapter 5 Branch Instructions and Logical Operations
113(30)
Types of Control Instructions
114(1)
Alpha Branch Instructions
114(5)
Conditional Branch Instructions
116(1)
Integer Compare Instructions
116(2)
Unconditional Branch Instruction
118(1)
DOT N: Using a Conditional Branch for Loop Control
119(3)
Locality and Symbolic Labels
122(1)
Loop Design and Program Efficiency
123(1)
Conditional Move Integer Instructions
124(2)
MAXIMUM: Using Conditional Move Instructions
126(2)
Logical Functions
128(4)
Shift Instructions
132(1)
RADIX2: Using Logical and Shift Instructions
133(2)
Integer Division Revisited
135(2)
DECNUM: Converting an Integer to ASCII Decimal Format
137(2)
Summary
139(1)
Bibliography
140(1)
Exercises
140(3)
Chapter 6 Working with Bytes on the Alpha
143(36)
Extract Byte Instructions
144(2)
Loading Unaligned Data
146(4)
Loading an Unaligned Quadword
147(1)
Loading and Zero-Extending an Unaligned Longword
148(1)
Loading and Sign-Extending an Unaligned Longword
149(1)
Loading and Zero-Extending an Unaligned Word
149(1)
Loading and Sign-Extending an Unaligned Word
149(1)
Loading and Zero-Extending a Byte
150(1)
Loading and Sign-Extending a Byte
150(1)
SCANTEXT: An Example of Byte Input
150(2)
Insert Byte Instructions
152(2)
Mask Byte Instructions
154(2)
Storing Modified Unaligned Data
156(4)
Storing an Unaligned Quadword
159(1)
Storing an Unaligned Longword
159(1)
Storing an Unaligned Word
160(1)
Storing a Byte
160(1)
Technical Specifications of the Extract, Insert, and Mask Byte Instructions
160(3)
Extract Byte Instructions
161(1)
Insert Byte Instructions
162(1)
Mask Byte Instructions
163(1)
Using C for ASCII Input and Output
163(6)
Introducing I/O for Open VMS
165(2)
Introducing I/O for Unix
167(2)
BACKWARD: Using Byte Manipulations
169(2)
Compare Byte Instruction
171(2)
Zero Bytes Instruction
173(1)
Summary
174(1)
Bibliography
175(1)
Exercises
175(4)
Chapter 7 Subroutines and Procedures
179(54)
Stacks
180(3)
Stack Addressing
180(2)
Stack Conventions (Unix)
182(1)
Stack Conventions (Open VMS)
182(1)
User-Defined Stacks
182(1)
DECNUM2: Stack Usage in an Algorithm
183(2)
Jump and Subroutine Instructions
185(3)
Branch to Subroutine Instruction
188(1)
NUMOUT: A Local Subroutine
188(4)
The Jump Group of Instructions
192(5)
Jump Tables
193(2)
Subroutine Calls
195(1)
Coroutines
196(1)
Conventions for Register Use
197(3)
Passing Arguments to Procedures
200(3)
Argument Information Register (OpenVMS)
200(1)
Argument Passing Methods
201(1)
String Descriptors (OpenVMS)
202(1)
Types of Alpha Procedures
203(5)
Procedure Descriptors
205(1)
How Programs are Started by Operating Systems
206(1)
Data Section Pointer (Open VMS)
207(1)
Global Pointer (Unix)
208(1)
Standard Prologue and Epilogue
208(4)
The $routine, $return, and $end routine Macros (Open VMS)
209(2)
Prologue and Epilogue for Unix
211(1)
Frame Pointer and Local Variables
212(2)
Stack Organization for Open VMS
212(1)
Stack Organization for Unix
213(1)
Integer Division on the Alpha
214(2)
Routines Related to Division (Open VMS)
215(1)
Pseudo-instructions for Division and Remainders (Unix)
215(1)
RANDOM: A Callable Procedure or Function
216(11)
RANDPROC: the Procedure Variant of RANDOM (Open VMS)
217(3)
RANDFUNC: the Function Variant of RANDOM (Open VMS)
220(4)
RANDFUNC: the Function Variant of RANDOM (Unix)
224(3)
The $call Macro (Open VMS)
227(2)
Summary
229(1)
Bibliography
229(1)
Exercises
230(3)
Chapter 8 Floating-Point Operations
233(24)
Parallels between Integer and Floating-Point Instructions
234(1)
IEEE Special Values
235(1)
Load and Store Floating-Point Instructions
236(4)
Loading and Storing 64-bit Data
237(1)
Loading and Storing 32-bit Data
237(1)
Addressing of Floating-Point Data in Memory
238(2)
Floating-Point Arithmetic Instructions
240(4)
Addition, Subtraction, Multiplication, and Division
240(1)
Rounding
241(1)
Exceptions
242(1)
Function Field in Floating-Point Instructions
243(1)
Floating-Point Branch Instructions
244(1)
Floating-Point Compare Instructions
245(1)
Floating-Point Conditional Move Instructions
246(1)
Copy Sign Instructions
247(1)
Data Conversion Instructions
248(2)
APPROXPI: Using Floating-Point Instructions
250(4)
Summary
254(1)
Bibliography
255(1)
Exercises
255(2)
Chapter 9 Conditional Assembly and Macros
257(30)
Repeat Blocks
258(3)
Simple Repeat Blocks
258(1)
Indefinite Repeat Blocks Using the .irp Directive
259(1)
Indefinite Repeat Blocks Using the .irpc Directive
260(1)
Conditional Assembly
261(5)
Conditional Assembly Blocks Using the .if Directive
262(2)
Single Conditional Alternative Using .else Directive
264(1)
Alternating the Conditional Assembly Using True-False Sense Switching
265(1)
One-Line Conditional Statements Using the .iif Directive
265(1)
Macro Processing
266(9)
Defining a Macro
267(1)
Invoking a Macro
268(1)
Processing of Positional Parameters
269(1)
Processing of Default Values and Keyword Parameters
270(2)
Processing of String Parameters
272(3)
Generating Unique Labels with Macros
275(1)
Self-Redefining and Recursive Macros, .mdelete, and .mexit
276(1)
Controlling the Listing File
277(1)
Defining Additional Program Sections with .psect
278(3)
MONEY: a Macro Illustrating Program Sections
281(3)
Summary
284(1)
Bibliography
284(1)
Exercises
284(3)
Chapter 10 Input and Output of Text
287(34)
File Systems
289(4)
Unix I/O Software
291(1)
Open VMS I/O Software
292(1)
A Simplifying Choice
293(1)
Keyboard and Display I/O
293(3)
Unformatted Line I/O (gets and puts)
295(1)
Formatted I/O (printf and scanf)
295(1)
SCANTERM: Using C Standard I/O
296(4)
SORTSTR: Sorting Strings from stdin
300(4)
Text File I/O
304(5)
Directory-Level Access (fopen and fclose)
306(1)
Unformatted Line I/O (fgets and fputs)
307(1)
Formatted I/O (fprintf and fscanf)
308(1)
SCANFILE: Input and Output with Files
309(4)
SORTINT: Sorting Integers from a File
313(4)
Binary Files
317(1)
Summary
317(1)
Bibliography
318(1)
Exercises
318(3)
Chapter 11 Performance Considerations
321(32)
Program Optimization Factors
322(3)
Instruction Size
322(1)
Addressing Mode
323(1)
Instruction Power
323(1)
Program Size
324(1)
Use of In-Lien Functions
324(1)
Recursion and Other Factors
325(1)
Fibonacci Numbers
325(1)
Local Variables in Recursion
326(1)
Three Fibonacci Implementations
327(6)
Full Procedure Call
327(3)
Internal Local Subroutine Call
330(1)
Non-Recursive Algorithm
331(2)
TESTFIB: Showing the Cost of Recursion
333(2)
Assembler Optimizations
335(6)
Instruction Rewriting
336(3)
Instruction Reordering
339(2)
Instruction Pipelining
341(8)
Pipeline Hazards
343(1)
Data Stalls
344(1)
Branch Effects
345(1)
Producer-Consumer Effects
345(2)
Multiple-Issue Effects
347(1)
Multiplication by a Constant
348(1)
Summary
349(1)
Bibliography
349(1)
Exercises
350(3)
Chapter 12 Looking at Output from Compilers
353(26)
Why RISC Systems Need Good Compilers
354(1)
Compiling a Simple Program
355(6)
Optimizing a Simple Program
361(4)
FORTRAN
364(1)
Pascal
364(1)
C
365(1)
Implementation-Dependent Optimizations
365(5)
Tuning for an Implementation
368(1)
Use of Newly-Added Instructions
369(1)
In-Line Optimizations
370(3)
Post-Compilation Optimization
373(1)
Debugging Optimized Programs
374(1)
Summary
374(1)
Bibliography
375(1)
Exercises
375(4)
Chapter 13 Extensions to the Basic Alpha Architecture
379(20)
Basic Alpha Architecture
381(1)
Alpha Implementation Differences
382(2)
Byte/Word Extension
384(2)
Motion Video Extension
386(2)
Count Extension
388(1)
Square Root and Floating-Point Register Move Extension
389(2)
Square Root Instructions
390(1)
Floating-Point Register Move Instructions
390(1)
Determining Extensions and Implementation Version
391(1)
Privileged Architecture Library
392(4)
Call_pal Instruction
393(1)
PALmode Environment
393(1)
Universal PALcode Instructions
393(2)
PALcode Specific to Operating Systems
395(1)
Summary
396(1)
Bibliography
396(1)
Exercises
397(2)
Suggested Resources
399(6)
System Hardware
399(1)
Unix
400(1)
Open VMS
400(1)
System Software for Programming Environments
400(1)
Unix
400(1)
Open VMS
401(1)
Desktop Client Access Software
401(1)
Windows 9x/NT
402(1)
Macintosh
402(1)
Windows NT on Alpha Systems
402(1)
Linux on Alpha Systems
403(1)
Hardware-Level Information
403(2)
Answers and Hints for Selected Exercises 405(8)
Index 413