《计算机系统概论》- 从门电路到超越

需积分: 12 155 浏览量更新于2024-07-19 2 收藏 12.96MB PDF 举报

"这是一本关于计算机系统的书籍，名为《Introduction to Computing Systems》，第二版，由The McGraw-Hill Companies出版。本书讲述了从基本的位和门电路到更高级的概念。内容涵盖了计算机科学的基础知识，可能包括硬件、软件、数据表示、计算原理等多个方面。此国际版专为非北美地区设计，不允许再出口，并且在电子形式的使用和复制上受到版权保护。" 《Introduction to Computing Systems》是计算机科学领域的基础教材，它深入浅出地介绍了计算机系统的方方面面。这本书的第二版更新了最新的技术和理论，旨在帮助读者理解计算机从底层硬件到高层软件的工作原理。首先，书中的"Bits and Gates"部分可能会详细讲解二进制系统以及逻辑门（如AND、OR、NOT门），这是构建所有数字电路的基础。这些基本的电路单元如何组合成复杂的逻辑电路，进而执行基本的计算任务，是这一阶段学习的重点。接下来，书中可能涉及“计算机组成原理”，包括处理器、内存、输入/输出系统等。这部分会解释CPU如何执行指令，内存如何存储数据，以及如何通过I/O设备与外部世界交互。在“数据表示”章节，读者将学习不同类型的数值（如整数、浮点数）和字符在计算机中的存储方式，以及如何进行算术和逻辑运算。此外，也可能涉及位操作、编码系统（如ASCII和Unicode）以及数据类型。 “编程和计算机语言”章节可能会涵盖高级语言、汇编语言以及编译器和解释器的工作原理。这部分将解释程序如何被转化为机器可执行的指令。此外，书中还可能探讨操作系统的作用，如进程管理、内存管理、文件系统等，以及计算机网络的基本概念，如TCP/IP协议栈、数据传输和网络安全。最后，“计算原理”部分可能涉及算法分析、复杂度理论以及计算理论的基础，如图灵机模型。《Introduction to Computing Systems》是一本全面介绍计算机科学的教科书，适合初学者和希望深化对计算机系统理解的学生阅读。通过学习，读者将能够从底层理解计算机的工作机制，为未来在IT领域进一步学习和工作打下坚实的基础。

preface to the first edition

This textbook has evolved from EECS 100, the first computing course for com-

puter science, computer engineering, and electrical engineering majors at the

University of Michigan, that Kevin Compton and the first author introduced for

the first time in the fall term, 1995.

EECS 100 happened because Computer Science and Engineering faculty

had been dissatisfied for many years with the lack of student comprehension of

some very basic concepts. For example, students had a lot of trouble with pointer

variables. Recursion seemed to be "magic," beyond understanding.

We decided in 1993 that the conventional wisdom of starting with a high-

level programming language, which was the way we (and most universities) were

doing it, had its shortcomings. We decided that the reason students were not

getting it was that they were forced to memorize technical details when they did

not understand the basic underpinnings.

The result is the bottom-up approach taken in this book. We treat (in order)

MOS transistors (very briefly, long enough for students to grasp their global

switch-level behavior), logic gates, latches, logic structures (MUX, Decoder,

Adder, gated latches), finally culminating in an implementation of

memory.

From

there, we move on to the Von Neumann model of execution, then a simple com-

puter (the LC-2), machine language programming of the LC-2, assembly language

programming of the LC-2, the high level language C, recursion, pointers, arrays,

and finally some elementary data structures.

We do not endorse today's popular information hiding approach when it

comes to learning. Information hiding is a useful productivity enhancement tech-

nique after one understands what is going on. But until one gets to that point, we

insist that information hiding gets in the way of understanding. Thus, we contin-

ually build on what has gone before, so that nothing is magic, and everything can

be tied to the foundation that has already been laid.

We should point out that we do not disagree with the notion of top-down

design. On the contrary, we believe strongly that top-down design is correct

design. But there is a clear difference between how one approaches a design

problem (after one understands the underlying building blocks), and what it takes

to get to the point where one does understand the building blocks. In short, we

believe in top-down design, but bottom-up learning for understanding.

Htiaf Is in the Booh

The book breaks down into two major segments, a) the underlying structure of a

computer, as manifested in the

LC-2;

and b) programming in a high level language,

in our case C.

The LC-2

We start with the underpinnings that are needed to understand the workings of a

real computer. Chapter 2 introduces the bit and arithmetic and logical operations

on bits, Then we begin to build the structure needed to understand the LC-2.

Chapter 3 takes the student from a MOS transistor, step by step, to a real memory.

Our real memory consists of 4 words of

bits each, rather than 64 megabytes. The

picture fits on a single page (Figure 3.20), making it easy for a student to grasp.

By the time the students get there, they have been exposed to all the elements that

make memory work. Chapter 4 introduces the Von Neumann execution model,

as a lead-in to Chapter 5, the LC-2.

The LC-2 is a 16-bit architecture that includes physical I/O via keyboard and

monitor; TRAPs to the operating system for handling service calls; conditional

branches on N, Z, and P condition codes; a subroutine call/return mechanism; a

minimal set of operate instructions (ADD, AND, and NOT); and various address-

ing modes for loads and stores (direct, indirect, Base+offset, and an immediate

mode for loading effective addresses).

Chapter 6 is devoted to programming methodology (stepwise refinement) and

debugging, and Chapter 7 is an introduction to assembly language programming.

We have developed a simulator and an assembler for the LC-2. Actually, we have

developed two simulators, one that runs on Windows platforms and one that runs

on UNIX. The Windows simulator is available on the website and on the CD-

ROM. Students who would rather use the UNIX version can download and install

the software from the web at no charge.

Students use the simulator to test and debug programs written in LC-2

machine language and in LC-2 assembly language. The simulator allows online

debugging (deposit, examine, single-step, set breakpoint, and so on). The sim-

ulator can be used for simple LC-2 machine language and assembly language

programming assignments, which are essential for students to master the concepts

presented throughout the first 10 chapters.

Assembly language is taught, but not to train expert assembly language pro-

grammers. Indeed, if the purpose was to train assembly language programmers,

the material would be presented in an upper-level course, not in an introductory

course for freshmen. Rather, the material is presented in Chapter 7 because it

is consistent with the paradigm of the book. In our bottom-up approach, by the

time the student reaches Chapter 7, he/she can handle the process of transform-

ing assembly language programs to sequences of 0s and Is. We go through the

process of assembly step-by-step for a very simple LC-2 Assembler. By hand

assembling, the student (at a very small additional cost in time) reinforces the

important fundamental concept of translation.

It is also the case that assembly language provides a user-friendly notation

to describe machine instructions, something that is particularly useful for the

xxii preface to the first edition

second half of the book. Starting in Chapter 11, when we teach the semantics of

C statements, it is far easier for the reader to deal with ADD Rl, R2, R3 than with

0001001010000011.

Chapter 8 deals with physical input (from a keyboard) and output (to a mon-

itor). Chapter 9 deals with TRAPs to the operating system, and subroutine calls

and returns. Students study the operating system routines (written in LC-2 code)

for carrying out physical I/O invoked by the TRAP instruction.

The first half of the book concludes with Chapter 10, a treatment of stacks

and data conversion at the LC-2 level, and a comprehensive example that makes

use of both. The example is the simulation of a calculator, which is implemented

by a main program and 11 subroutines.

The Language C

From there, we move on to C. The C programming language occupies the second

half of the book. By the time the student gets to C, he/she has an understanding

of the layers below.

The C programming language fits very nicely with our bottom-up approach.

Its low-level nature allows students to see clearly the connection between software

and the underlying hardware. In this book we focus on basic concepts such as

control structures, functions, and arrays. Once basic programming concepts are

mastered, it is a short step for students to learn more advanced concepts such as

objects and abstraction.

Each time a new construct in C is introduced, the student is shown the LC-2

code that a compiler would produce. We cover the basic constructs of C (vari-

ables, operators, control, and functions), pointers, recursion, arrays, structures,

I/O, complex data structures, and dynamic allocation.

Chapter 11 is a gentle introduction to high-level programming languages. At

this point, students have dealt heavily with assembly language and can understand

the motivation behind what high-level programming languages provide. Chapter

11 also contains a simple C program, which we use to kick-start the process of

learning C.

Chapter 12 deals with values, variables, constants, and operators. Chapter 13

introduces C control structures. We provide many complete program examples

to give students a sample of how each of these concepts is used in practice. LC-2

code is used to demonstrate how each C construct

affects

the machine at the lower

levels.

In Chapter 14, students are exposed to techniques for debugging high-level

source code. Chapter 15 introduces functions in C. Students are not merely

exposed to the syntax of

functions.

Rather they learn how functions are actually

executed using a run-time stack. A number of examples are provided.

Chapter 16 teaches recursion, using the student's newly gained knowledge of

functions, activation records, and the run-time stack. Chapter 17 teaches pointers

and arrays, relying heavily on the student's understanding of how memory is

organized. Chapter 18 introduces the details of I/O functions in C, in particular,

xxii preface to the first edition

streams, variable length argument lists, and how C I/O is affected by the various

format specifications. This chapter relies on the student's earlier exposure to

physical I/O in Chapter

Chapter 19 concludes the coverage of C with structures,

dynamic memory allocation, and linked lists.

Along the way, we have tried to emphasize good programming style and

coding methodology by means of examples. Novice programmers probably learn

at least as much from the programming examples they read as from the rules they

are forced to study. Insights that accompany these examples are highlighted by

means of lightbulb icons that are included in the margins.

We have found that the concept of pointer variables (Chapter 17) is not at all

a problem. By the time students encounter it, they have a good understanding of

what memory is all about, since they have analyzed the logic design of a small

memory (Chapter 3). They know the difference, for example, between a memory

location's address and the data stored there.

Recursion ceases to be magic since, by the time a student gets to that point

(Chapter 16), he/she has already encountered all the underpinnings. Students

understand how stacks work at the machine level (Chapter 10), and they under-

stand the call/return mechanism from their LC-2 machine language programming

experience, and the need for linkages between a called program and the return to

the caller (Chapter 9). From this foundation, it is not a large step to explain func-

tions by introducing run-time activation records (Chapter 15), with a lot of the

mystery about argument passing, dynamic declarations, and so on, going away.

Since a function can call a function, it is one additional small step (certainly no

magic involved) for a function to call itself.

Horn to Use This Booh

We have discovered over the past two years that there are many ways the material

in this book can be presented in class effectively. We suggest six presentations

below:

1. The Michigan model. First course, no formal prerequisites. Very intensive,

this course covers the entire book. We have found that with talented, very

highly motivated students, this works best.

2. Normal usage. First course, no prerequisites. This course is also intensive,

although less so. It covers most of the book, leaving out Sections 10.3 and

10.4 of Chapter 10, Chapters 16 (recursion), 18 (the details of C I/O), and

19 (data structures).

3. Second course. Several schools have successfully used the book in their

second course, after the students have been exposed to programming with

an object-oriented programming language in a milder first course. In this

second course, the entire book is covered, spending the first two-thirds of

the semester on the first 10 chapters, and the last one-third of the semester

on the second half of the book. The second half of the book can move

more quickly, given that it follows both Chapters 1-10 and the

preface to the first edition

xxi

introductory programming course, which the student has already taken.

Since students have experience with programming, lengthier

programming projects can be assigned. This model allows students who

were introduced to programming via an object-oriented language to pick

up C, which they will certainly need if they plan to go on to advanced

software courses such as operating systems.

4. Two quarters. An excellent use of the book. No prerequisites, the entire

book can be covered easily in two quarters, the first quarter for Chapters

1-10, the second quarter fcr Chapters 11-19.

5. Two semesters. Perhaps the optimal use of the book. A two-semester

sequence for freshmen. No formal prerequisites. First semester, Chapters

1-10, with supplemental material from Appendix C, the Microarchitecture

of the LC-2. Second semester, Chapters 11-19 with additional substantial

programming projects so that the students can solidify the concepts they

learn in lectures.

6. A sophomore course in computer hardware. Some universities have found

the book useful for a sophomore level breadth-first survey of computer

hardware. They wish to introduce students in one semester to number

systems, digital logic, computer organization, machine language and

assembly language programming, finishing up with the material on stacks,

activation records, recursion, and linked lists. The idea is to tie the

hardware knowledge the students have acquired in the first part of the

course to some of the harder to understand concepts that they struggled

with in their freshman programming course. We strongly believe the better

paradigm is to study the material in this book before tackling an

object-oriented language. Nonetheless, we have seen this approach used

successfully, where the sophomore student gets to understand the concepts

in this course, after struggling with them during the freshman year.

Some Observations

Understanding, Not Memorizing

Since the course builds from the bottom up, we have found that less memorization

of seemingly arbitary rules is required than in traditional programming courses.

Students understand that the rules make sense since by the time a topic is taught,

they have an awareness of how that topic is implemented at the levels below

it.

This

approach is good preparation for later courses in design, where understanding of

and insights gained from fundamental underpinnings are essential to making the

required design tradeoffs.

The Student Debugs the Student's Program

We hear complaints from industry all the time about CS graduates not being able

to program. Part of the problem is the helpful teaching assistant, who contributes

far too much of the intellectual component of the student's program, so the student

剩余628页未读，继续阅读

_phelps_

粉丝: 0
资源: 2

《计算机系统概论》- 从门电路到超越

卡内基梅隆CS神课Introduction to Computer Systems CMU15-213课件

Computing system 外教作业答案

IntroductiontoComputingSystems.rar

tigervnc-server-1.8.0-25.el7_9.x86_64

vnc-server-4.1.2-14.el5_6.6.x86_64

seed = 1 random.seed(seed) torch.manual_seed(seed) np.random.seed(seed) torch.cuda.manual_seed(seed)

nx.to_numpy_matrix

pytorch with torch.no_grad() english

tigervnc-server-1.8.0-22.el7.x86_64

最新资源