An In-Depth Understanding of Computer Systems – After Reading
[An In-Depth Understanding of Computer Systems – After Reading]
INTRODUCTION: This book details the essential concepts of computer systems from a programmer’s point of view and demonstrates how these concepts can actually affect the correctness, performance, and utility of an application, An In-Depth Understanding of Computer Systems – After Reading. The book consists of 12 chapters that focus on the representation and processing of information, machine-level representation of programs, processor architecture, optimizing program performance, memory hierarchies, linking, exception control flow, virtual memory, system-level I/O, network programming, and concurrent programming. Numerous examples and exercises with partial answers are provided to help readers deepen their understanding of the concepts and knowledge described in the text.
The greatest strength of this book is that it describes the implementation details of a computer system for the programmer, helping him or her to construct a hierarchical computer system in his or her brain, from the lowest level of representation of data in memory, to the composition of pipelined instructions, to the virtual memory, to the compilation system, to the dynamically loaded libraries, and finally to the user-state applications. By grasping how programs are mapped onto the system and how they are executed, readers are able to better understand why programs behave the way they do and how inefficiencies are caused.
The whole book will be hardware and software strung together to help us describe how the program is working in the system, the book’s link loading program layout, etc. I read in the “programmer’s self-cultivation”, a lot of the rest of the knowledge and the principles of computers, operating systems, systems programming also has a lot of overlap, the overall content is not very unfamiliar, but still a lot of gains. The third part of io network concurrency three chapters have not yet read
Write these words under the in order to help themselves better review the contents of the book, especially their previous mastery of the part is not deep
The first part of the book is the essence of the book, mainly about the program and hardware, except for the fourth chapter, I did not read
The second chapter, focusing on the representation of the number
Byte order Big end and little end
Format conversion of numbers First change the size, and then change the signed or unsigned, unsigned and signed implicit conversion brings disaster
Integer arithmetic Mainly all kinds of overflow problems
Floating-point numbers Multiplication does not have a combinability, the conversion of the integer can be overflow
Float numbers are not combinable, and can be overflowed
Converting the integer is a good idea. p>Chapter 3, focusing on assembler, personally I think the most rewarding chapter
various instructions, mov, leal, shifting, arithmetic, control, conditional transfer instructions*,
various reverse engineering, combined with the exercises is very interesting
frame stack structure when the function call
joint, structural data distribution and alignment of the problem
Memory overruns and buffer overflows
64-bit (didn’t look too closely, more registers are bigger, function calls are a lot different, many functions don’t need stack frames, parameters are transferred through registers)
Chapter 5, Program Optimization, the whole chapter consists of a single example throughout the beginning and end, quantifying the performance improvements that result from different approaches
Limitations of compiler optimization, limiting the ability to do so. ability to do so: the case of memory aliases, function calls (static variables, reentrant)
loop optimization, invariant variables counted only once
reducing function calls (a tradeoff between performance and readability)
unnecessary memory references (try to avoid unnecessary memory reads and writes by using temporary variables in registers)
from the processor’s point of view Consider (flow, predictive branching, critical paths), loop unrolling, consider flow (make full use of multiple adders in the processor, etc., superscalar)
Tools for program profiling, gprof
Chapter 6, Memory Hierarchy
Various storage technologies, registers, SRAM (cache), DRAM (memory), hard disks (traditional hard disks, SSD), network
various caches, cache L1L2 is the cache of memory, memory is the cache of the hard disk, the management mechanism of various caches (here only the cache, later will be memory management)
programs of the localization of time and space
the second part, mainly will be the program in the system’s operation, this part and the previous part of the The reason for the large gap is that I am more familiar with this part?
Chapter 7, Linking
See the book Programmer’s Self-Cultivation for a brief overview of target file formats, symbol parsing, and relocation
The linking order of static libraries, a problem that often goes awry
The use of some of the tools, readelf, objmp, ldd
I feel that from this chapter onwards, we can see how the programmer’s work is being done in the system. p>I feel that from this chapter onwards, the translation is very weak
Chapter 8, the name is very strange, called the exception control flow, talking about all levels of exceptions, in fact, I think this chapter might as well be called the process
Four types of exceptions: interrupts (IO devices), traps (trap, so how to translate this, the system caught in a how good, mainly system calls), faults (lack of page), termination < /p>
signal, read “A Deeper Understanding of Computer Systems”-reading. signal
non-local jumps, soft exceptions?setjmp,longjmp, is said to be the basis of the implementation of try\\catch
Some tools (pmap, strace, ps, top)
Chapter 9, Virtual Memory, the focus should be on memory management, the mechanism of address translation, I hate some places should be called memory but called memory
Memory management, the main two things to do, from the translation of the virtual address to the physical address, to provide memory read and write protection (read-only memory can not write, read-write-only can not run)
Memory management, mainly do two things, from virtual address to physical address translation, provides memory read and write protection (read-only memory can not write. read-only memory can not run)
Dynamic memory allocation, gives several allocator data structures, this part did not look closely
Various memory errors, summarized very well, basically I have made
Turning back to read the first chapter, people summarized it really well, the whole of a computer system is a big abstraction, the various hardware The system is abstracted into some simple concepts, these concepts allow us programmers to easily handle the program without having to care about the hardware, great ah
Three basic abstractions:
File – responsible for abstracting the IO device
Virtual memory -responsible for abstracting IO devices, memory
Processes-responsible for abstracting IO devices, memory, processors
The whole book is responsible for describing how to abstract
[A Deeper Understanding of Computer Systems – After Reading] With the following words: [This world’s Everything is accomplished by means of hope; a farmer will not peel a kernel of corn, if he has not hoped that it will grow to seed; a bachelor will not take a wife, if he has not hoped for children; a merchant will not go to work, if he has not hoped to be profitable by it.]
Introduction to Understanding Computer Systems in Depth
Introduction to Understanding Computer Systems in Depth
Introduction to Understanding Computer Systems in Depth
Understanding Computer Systems in Depth is the preferred title for understanding computer systems, and is the common choice of more than 100,000 programmers. Here is my compilation of an introduction to Understanding Computer Systems in Depth, welcome!
In-depth understanding of computer systems
Carnegie Mellon, Peking University, Tsinghua University, Shanghai Jiaotong University, and many other well-known colleges and universities at home and abroad to choose the designated textbook. From the programmer’s point of view, the comprehensive analysis of the implementation of the details, so that readers have a deep understanding of the behavior of the program, the relevant knowledge of all computer systems will be integrated .
Compared with the 2nd edition, the biggest change in the content of this edition is the shift from being based on IA32 and x86-64 to being based entirely on x86-64. The major updates are as follows:
Based on x86-64, extensive rewriting of the code, and the first introduction of machine-level support for programs that work with floating-point data.
The processor architecture was modified to support designs with 64-bit words and operations.
Expanded discussion of creating location-independent code with GOT and PLT, describing more powerful linking techniques (such as library staking).
Adds a more detailed description of signal-processing programs, including functions for asynchronous signal safety, and more.
Updated protocol-independent and thread-safe network programming with new functions.
Author: (US) Randal E. Bryant/David R. O’Hallaron Translator: Yili Gong/Yingchun Lei
Publisher: Mechanical Industry Press
Publication date: February 2011, 1st edition ISBN: 978-7-111-32133-0
English version –
Author: (US) RandalE.Bryant;DavidR.O’Hallaron
Publisher:Mechanical Industry Press
Publication date: December 27, 2010
This book focuses on the basic concepts of computer systems, including the representation of data in memory at the lowest level, the composition of pipelined instructions, virtual memory, compilation systems, dynamically loaded libraries, and user applications. The book provides a number of practical exercises that will help readers better understand how programs are executed and improve their execution efficiency. With a comprehensive explanation of computer systems from a programmer’s perspective and in-depth coverage of processors, compilers, operating systems, and network environments, this book is the definitive work in the field.
This book is suitable as a textbook for undergraduate students in computer science and related disciplines, as well as reference reading for programmers.
This book focuses on the basic concepts of computer systems, including the representation of data in memory at the lowest level, the `composition’ of pipelined instructions, virtual memory, compilation systems, dynamically loaded libraries, and user applications. The book provides a number of practical exercises that will help readers better understand how programs are executed and improve their execution efficiency. With a comprehensive explanation of computer systems from a programmer’s perspective and in-depth coverage of processors, compilers, operating systems, and network environments, this book is the definitive work in the field.
Randal E. Bryant: Ph.D. in Computer Science from MIT in 1981, currently Dean of the School of Computer Science at Carnegie Mellon University, and a dual Fellow of both the ACM and the IEEE, where he has received numerous awards from both societies, Prof. Bryant has taught computer systems for more than 20 years. Professor Bryant has been teaching computer systems for more than 20 years, and combined with years of experience teaching computer architecture courses, he has begun to shift his focus from how to design computers to how to use programmers to write more efficient and reliable programs with a better understanding of the system.