Microprocessor Visualization Program
Content:-
- Program conceptual model
- The Idea of Computer Visualization Program
1.2Computer Architecture (Undergraduate Course)
1.3Microprocessor (Undergraduate Course)
1.4Supercomputer (Training Course)
1.5Software Required
- Course one (Computer Architecture for (4th year students, 1st term)
2.1-Data statistics of the basic knowledge /design skills
2.1.1Analysis of the exciting course and determine the key points of taught knowledge
2.1.2Compare these key points with that gained in the courses taught in the advanced international universities.
2.1.3 Design, distribute, collect, and analyze a questionnaire for undergraduates, recent graduates, academic staff, and industrial supervisors to identify their opinions about the required knowledge/design skills for the selected program.
2.2New framework matrix
2.3 Syllabus of Computer Architecture Course
2.4 Experts Evaluations
- Course two (Microprocessor for (3rd year students, 2sc term)
1. Conceptual Model
1.1 The Idea of Computer Visualization Program
To execute an instruction on a microprocessor, it should follow the following sequence:
- fetch the instruction from memory,
- decode the fetched instruction and read its operands form the register file,
- execute the operation on the operands,
- access the memory if needed, and
- write back the result into the register file.
There are many techniques studying in the computer architecture to accomplish these steps, which should be understood in the undergraduate classes such as computer organization, microprocessor, and computer architecture in the computer science and engineering.
The problem faced by most of students is how to imagine those steps. So, our idea is to visualize the execution of a microprocessor. It will help the students to deeply understand how computers work as well as it will help the instructor to demonstrate his ideas easily.
This idea will help not only undergraduate students but also graduate ones in the computer science and engineering faculties as well as industrial people who are interested in the computer science and engineering. Any instructor who wants to use these materials can download it form internet (from the project web-site) and use it easily. This will wide the range of the benefits behind this idea.
Computer Visualization program consists of two teaching courses in the Electrical Engineering Division for undergraduate students and one training course for graduate students.
- Computer Architecture: This courseis in the 4thyear of the Control Computer Section. The Computer Architecture course is taught in the first semester.
- Microprocessor:This course is in the 3rdyear of the Control & Computer Section. The Microprocessor course is taught in the second semester.
- Supercomputer: This training course is devoted for the electrical engineers who are interested in Supercomputer design.
This program “Computer Visualization” visualizes the execution of a software program on computer. In the computer architecture course, the instructions of a computer program are translated into machine level. The execution of the machine level instructions is visualized step by step by using software called “RaVi”. However, the microprocessor course visualizes the execution of a program written in Assembly language, which is a higher level than machine level language. The execution of the Assembly language instructions is visualized step by step by using software called
“Emu8086”. According to the project there will be some new skills in every course. However, students and engineers have to know some basic knowledge to be familiar with these skills.
Details of these three courses are as follows:
1.2Computer Architecture (Undergraduate Course)
The main goal of this course is to provide students with a complete overview of the basic knowledge of computer architecture.
- Basic knowledge
- Fundamentals of Computer Design
- Technology Trends
- Cost, Price and their Trends
- Measuring and Reporting Performance
- Performance and Price-Performance
- Amdahl Low
- Instruction Set Principles
- Classifying Instruction Set Architectures
- Memory Addressing
- Addressing Modes for Signal Processing
- Type and Size of Operands
- Operands for Media and Signal Processing
- Operations in the Instruction Set
- Operations for Media and Signal Processing
- Instructions for Control Flow
- Encoding an Instruction Set
- The MIPS Architecture
- Pipelining of Instruction Execution
- What Is Pipelining?
- The Basic Pipeline for MIPS
- Pipeline Hazards
- Data Hazards
- Control Hazards
- What Makes Pipelining Hard to Implement?
- Extending the MIPS pipeline to Handle Floating-point Operations
- Instruction Set Design and Pipelining
- The MIPS R4000 Pipeline
- Instruction-Level Parallelism and its Dynamic Exploitation
- Concepts and Challenges of Instruction-Level Parallelism
- Overcoming Data Hazards with Dynamic Scheduling
- Dynamic Scheduling: The Idea
- Dynamic Scheduling with a Scoreboard
- Another Dynamic Scheduling Approach:The Tomasulo Approach
- Reducing Branch Costs with Dynamic Hardware Prediction
- High Performance Instruction Delivery
- Taking Advantage of More Instruction-Level Parallelism withMultiple Issue
- Hardware-Based Speculation
- Studies of the Limitations of Instruction-Level Parallelism
- Vector Processing
- Why Vector Processors?
- Basic Vector Architecture
- Performance of Vector Processors
- Skills
- Translate a higher level instructions to machine code
- Simulate the execution of instructions on SPIM
- Visualize how a simple program is executed without pipeline using multi-cycle approach.
- Visualize how a simple program is executed with pipeline.
- Visualize the effect of hazards on the performance
- Visualize the forwarding method to improve the performance.
- Visualize how multiple instructions can be executed per clock cycle.
1.3 Microprocessor(Undergraduate Course)
The main course goal is to provide students with a complete overview of Assembly programming language.
- Basic knowledge
- Introduction to Computing
- Numbering and coding systems
- Inside the computer
- Brief history of the CPU
- The 80x86Microprocessor
- Brief history of the 80x86 family
- Inside the 8088/8086
- Introduction to Assembly programming
- Introduction to program segments
- 80x86 addressing modes
- Assembly Language Programming
- Directives and a sample program
- Control transfer instructions
- Data types and data definitions
- EXE versus COM files
- Arithmetic and Logic Instructions.
- Unsigned addition and subtraction
- Unsigned multiplication and division
- Logic instructions
- Shift and rotate instruction
- BCD and ASCII operands and instructions
- BIOS and DOS Programming in Assembly Language.
- BIOS INT 10H programming
- DOS INT 10H programming
- INT 16H Keyboard programming
- Signed Numbers, Strings, and Tables
- Signed number arithmetic operations (addition, subtraction, multiplication, and division)
- String operations (load string, store string, compare strings, etc)
- Table operations
- 32-bit Programming for 386 and 486 machines
- General registers and pointers in 386/486
- Some simple 386/486 programs
- 80x86 performance comparison
- Floating-point Operations.
- Math coprocessor and IEEE floating-point standards
- Real/integer/packed-decimal transfer instructions
- Addition/subtraction/multiplication/division instructions
- Reversed subtraction/division instructions
- Compare instructions
- Constant instructions
- Processor control instructions
- Skills
- Be familiar with the MASM program
- Assemble, link, and rum a simple Assembly language program
- Visualize simple Assembly language instructions such as MOV
- Visualize control transfer instructions
- Visualize unsigned arithmetic instructions
- Visualize logic instructions
- Visualize BCD and ASCII arithmetic instructions
- Visualize shift and rotate instructions
- Visualize signed arithmetic instructions
- Visualize a complete Assembly language program for 8086 machines
- Visualize a complete Assembly language program for 80386 machines
1.4 Supercomputer (Training Course)
The main course goal is to provide engineers, graduate students, with an advanced overview of supercomputersdesign.
- Basic knowledge
- Impacting Factors on the Processor Architecture
- Moore’s law
- Intel® Pentium® 4 Processor Overview
- MMX, SSE, and SSE2 Technologies
- Intel® NetBurstTM Microarchitecture
- Improving Performance by Pipelining Technique
- SSE Instruction Set in Details (Special Case of Vector ISA)
- Introduction to Supercomputer
- The Architecture of the Earth Simulator Supercomputer
- How to Improve the Performance of a Supercomputer
- Why Vector Instruction Set Architecture Is Suitable for Supercomputers
- Skills
- Writing program for supercomputers using vector instructions
- Measuring the performance of supercomputers
1.5 Software Required
- RaVi: Computer Architecture Visualization. The source code of RaVi will be downloaded freely from the following site
- Emu8086: The 80x86 Emulator. The software for Emu8086, which is cheep, will be bought from
3. Intel Compiler for SSE instructions
- RaVi
Computer Architecture Visualization (RaVi) is a set of interactive training components for the teaching of the computer architecture. Each component visualizes an aspect of the dynamic behavior that is found in computer architectures. The development of these components has been trigged by the lack on interactive teaching (learning) material in the context of computer engineering. There was a demand on dynamic and interactive teaching material which supplies more facilities than a slide presentation or an animation.
The components of RaVi provide an opportunity to change the parameters or the input values interactively and to directly observe the variances in the behavior described by the component. For example, the execution of instructions is not fixed and cannot be effectively visualized using earlier tools. During the demonstration the lecturer can change the instructions and show the differences between the data routes taken.
An additional aspect is that RaVi supports explorative learning. The integration of the RaVi components into labs for example is a way to make them available for the students. This way, the students have the chance to explore the dynamic behavior themselves and this means an essential improvement of the teaching material for computer architecture.
For making the RaVi components usable for a large number of lecturers, all examples based on the book “Computer Organizition and Design” of John L. Hennessy and David A. Patterson, which is the standard book for teaching computer architecture all over the world. The RaVi components have been used in lectures on computer architecture at the University of Dortmund, Germany. The components have been evaluated and the feedback is considered during the development of components.
- Emu8086
Emu8086 is a Microprocessor Emulator with integrated 8086 Assembler and Free Tutorial. Emulator runs programs on a Virtual Machine, it emulates real hardware, such as screen, memory and input/output devices. Emu8086 works under any version of Windows including Windows XP.
Emu8086 is extremely helpful for programming in assembly language. The source code is compiled by assembler and then executed on Emulator step-by-step, allowing you to watch registers, flags and memory while your program runs. Complete 'all in one' solution for coding in Assembly Language.Everything for learning assembly languagein one pack! Emu8086 combines an advancedsource editor, assembler, disassembler,software emulator (Virtual PC) with debugger,and step by step tutorials.
This program is extremely helpfulfor those who just begin to study assemblylanguage. It compiles the source codeand executes it on emulator step by step.Visual interface is very easy to work with.You can watch registers, flags and memory whileyour program executes.Arithmetic & Logical Unit (ALU) shows theinternal work of the central processorunit (CPU).Emulator runs programs on a Virtual PC,this completely blocks your program from accessingreal hardware, such as hard-drives and memory,since your assembly code runs on a virtual machine,this makes debugging much easier.
8086 machine code is fully compatible with all nextgenerations of Intel's micro-processors, includingPentium II and Pentium 4, I'm sure Pentium 5 willsupport 8086 as well. This makes 8086 code veryportable, since it runs both on ancient and onthe modern computer systems. Another advantageof 8086 instruction set is that it is much smaller,and thus easier to learn.
2. Course one(Computer Architecture for (4th year students, 1st term)
2.1Data statistics of the basic knowledge /design skills
2.1.1Analysis of the exciting course and determine the key points of taught knowledge:-
The actual course studies the following subjects:
- Fundamentals of Computer Design: Covers the basic quantitative principles of computer design and performance measurement. It also addresses the role of technology and the factors affecting the cost of computer system.
- Instruction Set Principles: Covers instruction set design principles. Besides, it describes the MIPS64 architecture used throughout the course.
- Pipelining of Instruction Execution: Show a realistic example of a processor in details. It shows how all the pieces of a processor fit together for a pipelined and unpipelined machine.
- Instruction-Level Parallelism and its Dynamic Exploitation: Covers the exploitation of instruction-level parallelism in high-performance processors, including very long instruction word (VLIW) processors, superscalar execution, branch prediction, speculation, and dynamic scheduling.
- Memory hierarchy Design: reviews cache principles, which is covered in the computer organization course, 3rd year in computer & Control Section.
- Multiprocessors: Discusses multiprocessor systems, focusing on shared-memory architectures.
- Interconnection Networks and Clusters: Provides an introduction to networks from computer architecture view. There is a separate course in the 2nd term focusing on networks.
- Vector Processing: Covers the architecture of vector machines. It also demonstrates the advantages of using vector instruction set over the scalar one.
References:
J. Hennessy and D. Patterson. Computer Architecture: A Quantitative Approach, Morgan Kaufmann, San Francisco, CA, 3rd Edition, 2003.
D. Patterson and J. Hennessy, Computer Organization and Design: The Hardware/Software Interface, Morgan Kaufmann, San Francisco, CA, 3rd Edition, September 2005.
2.1.2 Compare these key points with that gained in the courses taught in the advanced international universities.
The text book chosen for the computer architecture course is the standard text book for many international universities, for example BarkleyUniversity at California, USA and the University of Dortmund, Germany.
2.2 New framework matrix
Based on the previous review of the actual taught and that taught in the advanced universities with the student feedback through the designed questionnaire, we summarize the new conceptual model for the Computer Architecture course to be as:-
Week # / Title / Lecture / Section1 / Fundamentals of Computer Architecture:
Technology / Chapter1 Technology
Slides 1-23 / Sheet1 Technology
2 / Fundamentals of Computer Architecture:
Measuring and Reporting Performance / Chapter1 Technology
Slides 24-48 / Sheet1 Technology
3 / Instruction Set Architecture:
Designing Instruction Set / Chapter2 ISA
Slides 1-54 / Sheet2 ISA
+
SPIM
4 / Instruction Set Architecture:
The MIPS Architecture / Chapter2 ISA
Slides 55-88 / Sheet2 ISA
+
SPIM
5 / Pipelining:
Unpipelined/pipelined Implementation of a RISC ISA / Chapter3 Pipeline
Slides 1-67 / Sheet3 Pipeline
+
RaVi: Microprog
6 / Pipelining:
Implementing the Control for the MIPS Pipeline / Chapter3 Pipeline
Slides 68-97 / Sheet3 Pipeline
+
RaVi: Pipeline1
7 / Pipelining:
Extending the MIPS Pipeline to Handle Floating-point Operations / Chapter3 Pipeline
Slides 98-135 / RaVi: Pipeline2
+
Pipeline3
8 / Instructional Level Parallelism:
Dynamic Scheduling with a Scoreboard / Chapter3 Pipeline
Slides 136-166 / Sheet4 ILP
+
RaVi: scoreboard
9 / Instructional Level Parallelism:
Dynamic Scheduling Using Tomasulo’s Approach / Chapter4 ILP
Slides 1-57 / Sheet4 ILP
+
RaVi: Tomasulo
10 / Instructional Level Parallelism:
High Performance Instruction Delivery / Chapter4 ILP
Slides 58-96 / Sheet4 ILP
11 / Vector Processing:
Why Vector Processors? / Chapter5 DLP
Slides 1-14 / Sheet5 DLP
12 / Vector Processing:
Vector Instruction Set / Chapter5 DLP
Slides 15-33 / Sheet5 DLP
2.3 Syllabus of Computer Architecture Course
Introduction to parallel processing
Fundamentals of Pipeline and vector processing
Pipeline processors
SIMD processors
Array processors
Multiprocessor architecture and programming
2.4Evaluate these objectives by panel of experts based on theproject objectives and then revise them based on the evaluation.
- Course Two(Microprocessor for (3rd year students, 2sc term)
The actual course studies the following subjects:
- Introduction to computing: covers concepts in number systems (binary, decimal, octal, and hex). Most students have learned these concepts in previous courses, but this introduction provides a quick overview for those students who have not learned these concepts, or who may need to refresh their memory.
- The 80x86microprocessor: provides a brief history of the evolution of 80x86 microprocessors and an overview of the internal working of the 8086 as a basis of all 80x86 processors.
- Assembly Language Programming: explains the use of assemblers to create programs.
- Arithmetic and Logic Instructions: introduces the bulk of the logic and arithmetic instructions for the unsigned numbers.These instructions include unsigned addition and subtraction, unsigned multiplication and division, logic instructions, shift and rotate instruction, and BCD and ASCII operands and instructions.
- BIOS and DOS Programming in Assembly Language: introduces DOS and BOIS interrupts. Programs in Assembly allow the students to get inputs from keyboard and send output to the monitors. These interrupts include BIOS INT 10H, DOS INT 10H, and INT 16H Keyboard.
- Signed Numbers, Strings, and Tables: covers arithmetic and logic instructions for signed numbers (addition, subtraction, multiplication, and division) as well as string and table processing instructions (load string, store string, compare strings, etc).
- 32-bit Programming for 386 and 486 machines: introduce some 32-bit concepts of 80386 and 80486 programming. This helps the students to appreciate the power of 32-bit CPUs. Several programs are run across the 80x86 family to show the dramatic improvement in clock cycles with the newer CPUs.
- Floating-point Operations: covers IEEE floating-point standard for single-precision (32-bit) and double-precision (64-bit) as well as the floating-point instructions for the math coprocessor. Floating-point instructions include real/integer/packed-decimal transfer, addition/subtraction/multiplication/division, reversed subtraction/division, compare constant, processor control instructions.
References:
Muhammad Ali Mazidi and Janice Gillispie Mazidi, The 80x86 IBM PC and Compatable Computers: Assembly Language, Design, and Interface, Prentice Hall, 3rd Edition, 2000.
3.1 New framework matrix
Based on the previous review of the actual taught and that taught in the advanced universities with the student feedback through the designed questionnaire, we summarize the new conceptual model for the Microprocessor course to be as:-
Week # / Title of Lecture / Section1 / Introduction to Computing / Sheet-1
2 / Evolution of Intel’s Processors / Sheet-2
3 / Introduction to Assembly Programming / Sheet-3
4 / Stack Segment and Flag Register / Sheet-4
5 / Directives and Interrupts / Sheet-5
6 / Unsigned Arithmetic Instructions / Sheet-6
7 / Logical and Shift Instructions / Sheet-7
8 / BCD, ASCII, and Control Instructions / Sheet-8
9 / Signed Numbersstrings and tables / Sheet-9
10 / 32-bit Programming for 386 and 486 Machines / Sheet-10
11 / IEEE floating-point format and
Introduction to 80x87 Math Coprocessor / Sheet-11
12 / 8087 instruction set and Examples / Sheet-12
Syllabus of Microprocessor