Book Image

Computer Architecture with Python and ARM

By : Alan Clements
Book Image

Computer Architecture with Python and ARM

By: Alan Clements

Overview of this book

This comprehensive guide offers a unique and immersive learning experience by combining Python programming with ARM architecture. Starting with an introduction to computer architecture and the flow of data within a computer system, you’ll progress to building your own interpreter using Python. You’ll see how this foundation enables the simulation of computer operations and learn ways to enhance a simulator by adding new instructions and displaying improved results. As you advance, you’ll explore the TC1 Assembler and Simulator Program to gain insights into instruction analysis and explore practical examples of simulators. This will help you build essential skills in understanding complex computer instructions, strengthening your grasp of computer architecture. Moreover, you’ll be introduced to the Raspberry Pi operating system, preparing you to delve into the detailed language of the ARM computer. This includes exploring the ARM instruction set architecture, data-processing instructions, subroutines, and the stack. With clear explanations, practical examples, and coding exercises, this resource will enable you to design and construct your own computer simulator, simulate assembly language programs, and leverage the Raspberry Pi for ARM programming.

Related Content you might be interested in

Current Title:

Small book image
Computer Architecture with Python and ARM
Alan Clements
Jul, 2023 | 412 pages
Small book image
Modern Computer Architecture and Organization
Jim Ledin
Apr, 2020 | 560 pages
Small book image
Modern Computer Architecture and Organization – Second Edition
Jim Ledin
May, 2022 | 666 pages
Table of Contents (18 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Conventions used
Get in touch
Share Your Thoughts
Download a free PDF copy of this book
1
Part 1: Using Python to Simulate a Computer
Part 1: Using Python to Simulate a Computer
Free Chapter
2
Chapter 1: From Finite State Machines to Computers
Chapter 1: From Finite State Machines to Computers
Technical requirements
The finite state machine
Summary
3
Chapter 2: High-Speed Introduction to Python
Chapter 2: High-Speed Introduction to Python
Technical requirements
Reading programs
Getting started with Python
Python’s data types
Mathematical operators
Names, values, and variables
Comments
Functions in Python
Conditional operations and decision-making
Computer memory
Summary
4
Chapter 3: Data Flow in a Computer
Chapter 3: Data Flow in a Computer
Technical requirements
The Instruction Architecture Level (ISA)
The von Neumann architecture
An assembly-level program
The machine-level instruction
Summary
5
Chapter 4: Crafting an Interpreter – First Steps
Chapter 4: Crafting an Interpreter – First Steps
Technical Requirements
Building a simple computer interpreter in Python
Decoding and executing an instruction
Functions in Python
Summary
6
Chapter 5: A Little More Python
Chapter 5: A Little More Python
Technical requirements
More string features
String processing
List comprehensions
Summary
7
Chapter 6: TC1 Assembler and Simulator Design
Chapter 6: TC1 Assembler and Simulator Design
Technical requirements
Analyzing instructions
Dealing with assembler directives
Building the binary instruction
Intermission: The Pre-TC1
The TC1 simulator program
Example of a TC1 assembly language program
Testing the assembler
TC1 postscript
TC1 postscript mark II
Summary
8
Chapter 7: Extending the TC1
Chapter 7: Extending the TC1
Technical requirements
Another look at python’s input and output
Input validation
Adding new instructions
A new comparison operation
Variable-length instructions
Summary
9
Chapter 8: Simulators for Other Architectures
Chapter 8: Simulators for Other Architectures
Technical requirements
TC0: A stack-based calculator
TC2: A one-address accumulator machine
TC3: A CISC machine with a register-to-memory architecture
The complete TC3 code
Arithmetic and Logic Unit (ALU)
A final example: TC4
Summary
10
Part 2: Using Raspberry Pi to Study a Real Computer Architecture
Part 2: Using Raspberry Pi to Study a Real Computer Architecture
11
Chapter 9: Raspberry Pi: An Introduction
Chapter 9: Raspberry Pi: An Introduction
Technical requirements
Raspberry Pi basics
Basics of the Raspberry Pi operating system
Features of the GCC ARM assembler
Dealing with 32-bit literals
Summary
12
Chapter 10: A Closer Look at the ARM
Chapter 10: A Closer Look at the ARM
Technical requirements
Introducing the ARM
Overview of the ARM’s architecture
Flow control instructions
Conditional executions
Summary
13
Chapter 11: ARM Addressing Modes
Chapter 11: ARM Addressing Modes
Literal addressing
Register indirect addressing
Program counter-relative addressing
Summary
14
Chapter 12: Subroutines and the Stack
Chapter 12: Subroutines and the Stack
The Branch with link instruction
A subroutine call and return
Block move instructions
Summary
15
Index
Index
Why subscribe?
16
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts
Download a free PDF copy of this book
Appendices – Summary of Key Concepts
Appendices – Summary of Key Concepts
Using IDLE
Instructions and commands
Running an ARM program
Common confusions
Vocabulary

What this book covers

  • Chapter 1, From Finite State Machines to the Computers, introduces the notion of digital computers via the finite state machine that is used to model simple control systems. From there, we introduce the concept of algorithms and programs. Once we know what we want a computer to do, we can think about what we need to implement a computer.
  • Chapter 2, High-Speed Introduction to Python, provides the initial background in Python that is required to take the first steps on the way to implementing a computer using Python.
  • Chapter 3, Data Flow in a Computer, demonstrates how information flows around a computer during the execution of a program. It is this data flow that we have to implement when we are simulating a program in software.
  • Chapter 4, Crafting an Interpreter – First Steps, begins the journey to a simulator. Now that we have been introduced to the concept of a computer and a little Python, we can go further and describe the fundamental ideas behind a computer simulator. In this chapter, we also look at the nature of computer instructions.
  • Chapter 5, A Little More Python, expands our knowledge of Python and introduces us to vital topics such as Python’s dictionaries, which provide tools that greatly simplify the design of a computer simulator.
  • Chapter 6, TC1 Assembler and Simulator Design, is the heart of this book. Here, we discuss the components of a simulator and then provide a program that can simulate a hypothetical teaching computer, TC1.
  • Chapter 7, Extending the TC1, adds further facilities to the simulator, such as data checking and creating new instructions.
  • Chapter 8, Simulators for Other Architectures, looks at different types of computer architecture and describes alternative simulators.
  • Chapter 9, Raspberry Pi – An Introduction, changes course. Here, we look at the popular Raspberry Pi and the ARM processor at its core. In particular, we learn how to enter a program in ARM assembly language and run it in debugging mode.
  • Chapter 10, A Closer Look at the ARM, examines ARM’s instruction set in greater detail and provides a foundation for writing programs in assembly language.
  • Chapter 11, ARM Addressing Modes, looks at the addressing modes of the ARM in greater detail and explains some of its special features.
  • Chapter 12, Subroutines and the Stack, is really an extension of the previous chapter because we look at the way in which the ARM uses its addressing modes to implement stack operations, which are so important in assembly language programming.
Previous Section
Next Section