Computer Systems: A Programmer's Perspective, 3rd Edition
By Randal E. Bryant, David R. O'Hallaron
About this ebook
Computer Systems: A Programmer's Perspective, Third Edition, explains how hardware and operating systems affect program execution. Bryant and O'Hallaron use C and x86-64 machine code to connect data representation, processor behavior, memory, linking, and concurrency for computer science students and programmers studying the systems beneath their software.
Inside this title
C programs connected with x86-64 assembly and machine behavior
Current listed price $30.99Regular price $81.00Digital ebook
Following a program beneath the source-code level reveals why representation, memory access, and operating system behavior matter. This text relates C programming to x86-64 assembly, explaining integer and floating-point data, generated machine code, processor architecture, and the effects of caches and locality on performance. Linking shows how separately compiled pieces become an executable program.
The systems discussion continues with exceptional control flow, processes, signals, virtual memory, memory mapping, and concurrency. These topics are framed around the consequences for programs rather than hardware design alone. Students entering computer systems coursework and programmers with a working knowledge of C can use the book to examine execution, diagnose low-level behavior, and reason about interactions between software and its environment.
Study guide included
Inside Computer Systems: A Programmer's Perspective, 3rd Edition.
Bryant and O'Hallaron follow a C program from source text down to machine execution and back out to networks. The result shows why routines that look interchangeable at the source can differ in correctness, speed and safety once representation, processor behavior, memory and concurrency are taken into account.
Compilation, binary encoding, x86-64 assembly and processor design occupy the opening chapters, followed by performance work tied to caches and the memory hierarchy. Later material covers linking, exceptional control flow, virtual memory, Unix input and output, sockets and concurrent programming. Worked examples stay concrete by using Linux and x86-64 throughout, so a reader can reason about one real platform while noting which principles carry over to other instruction sets and operating systems. Each chapter pairs explanation with exercises and worked traces that reward actually running the code.
Translation and data representation
A small C file passes through preprocessing, compilation, assembly and linking before the operating system loads it. Knowing that sequence separates errors the compiler reports from symbols the linker cannot resolve and faults that appear only after a process starts. Bit patterns acquire meaning from interpretation: unsigned and two's-complement integers cover different ranges, and mixing them can silently reverse a comparison. Floating point approximates and rounds.
Place each error at its stage of translation
Track operand widths and implicit conversions
Treat floating point as approximate arithmetic
Ch. 1–2
Instructions, procedures and processors
The machine-level tour follows arithmetic, branches, procedures, arrays and structures in x86-64. Registers and memory operands show which values are loaded and which addresses computed, while calling conventions decide where arguments and results travel. Stack layout matters because writing past a buffer can corrupt data or redirect execution. The simplified Y86-64 pipeline then shows how forwarding, stalls and recovery keep stages overlapped.
Derive effective addresses from base, index and width
Read the stack to trace a call
Separate visible behavior from timing
Ch. 3–4
Performance and memory hierarchy
Speed work begins with measurement. Repeated calls, superfluous memory references and long dependency chains limit throughput; unrolling exposes parallel work and multiple accumulators shorten a chain. Profiling locates the costly region and lets gains be weighed against added complexity. Caches reward neighboring and recently reused data, and the Memory Mountain demonstration varies stride and working-set size to show throughput shifting with both.
Profile before rewriting a loop
Change access order to gain locality
Keep comparisons controlled when timing
Ch. 5–6
Linking, processes and virtual memory
The linker matches symbolic references to definitions and fixes addresses as code and data are placed, and shared libraries add loading choices. Exceptions, interrupts, processes and signals describe control flow that happens outside an ordinary call. Virtual addresses are translated with memory-management structures and cached in the TLB; pages provide protection and separate address spaces. Allocation inside that space must balance throughput against fragmentation, and out-of-bounds access corrupts state even when the page permits it.
Follow a symbol from reference to definition
Translate virtual addresses through page structures
Look for the first invalid write
Ch. 7–9
Files, descriptors and network services
Descriptors name open streams the kernel manages, and reads and writes report only how much moved, so code must handle partial progress, end of file and error conditions. Robust wrappers organize those cases, while sharing and redirection follow from how descriptors point at shared open file state. Network programming builds from addresses and sockets to an echo service and the TINY web server, where recognizing request boundaries and handling disconnects remain application responsibilities.
Handle short reads as normal events
Remember descriptors share open file state
Find where a request ends
Ch. 10–11
Concurrency and shared state
Processes isolate state and simplify failure boundaries; I/O multiplexing drives many descriptors in one event loop; threads share an address space and can coordinate directly. Each choice alters memory cost, coordination burden and failure modes. A race appears when the outcome depends on access order, so a read-modify-write sequence may need protection as a single unit. Semaphores and progress graphs make synchronization and deadlock reasoning concrete, and hidden shared state threatens reentrancy.
Pick a concurrency model that fits the work
Protect the whole update, not the store
Check thread safety of persistent state
Ch. 12
Chapter and section map
Representing and manipulating informationCh. 2
Machine-level representation and processor architectureCh. 3–4
Optimizing program performance and the memory hierarchyCh. 5–6
Linking and exceptional control flowCh. 7–8
Virtual memoryCh. 9
System-level I/O and network programmingCh. 10–11
Concurrent programmingCh. 12
Key takeaways
Chase an odd result through types, representations and instructions before rewriting the algorithm.
Predict locality from working-set size and stride, then measure whether prediction holds.
Say exactly which operation must be atomic when several flows touch shared data.
Computer science undergraduates and graduate students taking systems courses, plus working programmers who want the machine-level reasoning behind performance, memory and concurrency behavior in their own code.
Topics covered
computer systems
x86-64 assembly
memory hierarchy
virtual memory
process control
network programming
concurrent programming
program optimization
Questions about this ebook.
Edition, audience, and study-guide details at a glance.
What is Computer Systems: A Programmer's Perspective, 3rd Edition about?
Computer Systems: A Programmer's Perspective, Third Edition, explains how hardware and operating systems affect program execution. Bryant and O'Hallaron use C and x86-64 machine code to connect data representation, processor behavior, memory, linking, and concurrency for computer science students and programmers studying the systems beneath their software.
Which edition of Computer Systems: A Programmer's Perspective, 3rd Edition is this?
This listing is for the 3rd edition. Check the title, ISBN, and book details above before ordering, especially if your course or reading list names a specific edition.
Who is Computer Systems: A Programmer's Perspective, 3rd Edition for?
Computer science undergraduates and graduate students taking systems courses, plus working programmers who want the machine-level reasoning behind performance, memory and concurrency behavior in their own code.
Does this page include a study guide?
Yes. This page includes an original study guide with six thematic sections, key takeaways, and a chapter and section map for structured reading.
