Computer Architecture Midterm

Figure 1: Moving between language levels.

– add 2 numbers,

– check to see whether a number is 0,

– copy a piece of data from one location to another.

· Machine language = the set of instructions that can be carried out on the electronic circuits that form a computer.

· People find it extremely difficult to understand such a language.

· People must understand the language in order to write programs.

· To bridge the gap between machine language and human (programmer’s) language, a series of abstractions have to be employed, leading to the structured organization of computers.

Translation and interpretation

Figure 1 presents the problem of moving between “machine” and “human” languages, and its solution.

Comparison: translation and interpretation

· Similar:

– instructions from L1 are ultimately carried out by executing equiva-lent sequences in L0.

· Different:

– Translation:

· a L1 program is converted into a L0 program;

· the L1 program is thrown away;

· the L0 program is loaded into the memory and executed;

· the new L0 program has control of the execution.

– Interpretation:

· after each L1 instruction is analyzed and decoded, it is carried out immediately (no translated program);

· the interpretor is in control of the program, the initial L1 pro-gram is just data.

Virtual machines

· Instead of thinking in terms of interpretation and translation, imagine a hypothetical computer, a virtual machine M1, able to “speak” the lan-guage L1.

· If the machine M1 can be constructed easily, there is no need for L0 (and the corresponding machine M0).

· If M1 is too difficult to construct, one can still write programs in L1 (for M1), and these can either be translated or interpreted into L0 (and run on M0).

· However, in order to make the translation/interpretation from/of L1 to/into L0, these language should not be “too different”. The initial picture (“hu-man” - “machine”) was too optimistic.

· Obvious solution: introduce intermediary levels (and virtual machines), so that moving between levels becomes easier. This leads to a hierarchy of language layers.

Multilevel machines

Figure 2 presents the structure of a multilevel machine.

Languages, virtual machines

· A virtual machine defines its machine language (as the set of all instruc-tions which can be executed on that machine).

· A language defines its machine (as the machine that can execute all pro-grams written in the respective language).

· Machines based on arbitrary languages can be arbitrarily hard to build (complicated, expensive).

· Example: C++, Cobol machines can be constructed with the technology today, but would not be cost effectives.

· A computer with n levels can be seen as n different machines, each with its own language.

· The terms “level” and “virtual machine” can be used interchangeably.

Figure 2: A multilevel machine.

Modern multilevel machines.

· Contemporary multilevel machines have two or more levels. Figure 3 presents a machine with 6 levels

The digital logic level

· Gates:

– built from analog devices, can be accurately modeled as digital de-vices,

– each gate has one or more digital inputs (i.e. 0,1) and generate simple digital outputs,

– each gate can be built out of a handful of transistors,

– a small number of gates can be combined to form 1 bit memories (stores for one of two values: 0,1).

· Registers:

– combinations of typically 16, 32, 64 1 bit memories,

– each can hold a simple binary number up to some maximum.

· Gates can also be combined to form the main computing engine.

Figure 3: A multilevel machine with 6 levels. The way of moving between levels (translation/interpretation) is indicated along with the name of the program to do this.

The microarchitecture level

· A collection of (typically) 8 to 32 registers that form a local memory.

· A circuit – arithmetic logical unit (ALU) – capable of carrying out simple operations.

· Data path that connects the registers to the ALU, ensuring the data flow.

Example: select 2 registers, pass the content to the ALU where the values are added, then store the result in some other register.

· On some machines, the operations in the data path is controlled by a microprogram, in others this is done directly in hardware.

The instruction set architecture (ISA) level

· This is what is usually described in the “Machine language reference man-ual”.

· It contains the machine’s instruction set.

· These instructions are carried out interpretatively by the microprogram or by the hardware execution circuits.

The operating system machine level

· Most instructions in the language of this level can be found also on the ISA level.

· However, in addition:

– there is a new set of instructions,

– the memory is organized in a different way,

– it is possible to run two or more programs in the same time.

· The new instructions are interpreted by an interpretor at the ISA level (historically called the operating system).

· The instructions that are identical to those at the ISA level are interpreted by the microprogram or the hardware (at the microarchitecture level).

· Note that the operating system machine level is a hybrid level (instructions interpreted at 2 levels).

Some considerations regarding the levels

· The levels discussed so far:

– are intended primarily for running interpretors and translators to support higher levels;

– these are written by system programmers.

· The remainding levels are for application programmers.

· Other differences:

– method of language support:

levels 1-2-3: interpretation,

levels 4-5: (mostly) translation;

– nature of the language:

levels 1-2-3: numeric (hard to read by humans),

levels 4-5: words and abbreviations.

The assembly language level

· The language presents an abbreviation for the languages at levels 1-2-3.

· Programs in assembly languages are first translated, then interpreted by the appropriate machine for which instructions were intended.

· The program that performs the translation is called the assembler.

The problem oriented language level

· Contains the languages for application programmers (high level languages).

· There are hundreds of such languages.

Basic, C, C++, Java, LISP, Prolog, Mathematica, Python, : : : (add your favorite).

· Generally, the programs written in one of the high level languages are (can be) translated into level 3 or level 4 by translators called compilers.

Hardware, software - some considerations

· Initially:

HARDWARE: the electronic circuits (level 0) along with the memory and the input-output devices.

SOFTWARE: algorithms (detailed instructions telling how to do some-thing) and their computer representations (programs).

· However, in time, the distinction between hardware and software blurred:

“Hardware and software are logically equivalent”.

“Hardware is petrified software”.

– Any operation performed by software can be built into the hardware.

– Any hardware operation can be simulated by software.

· The above points will be illustrated by taking a look at the development of multilevel machines.

Invention of microprogramming

· In the 1940s computers had two levels: digital logic and instruction set architecture:

– they were complicated to build,

– difficult to understand,

– unreliable.

· 1951, Maurice Wilkes (University of Cambridge) had the idea to introduce an additional level (microarchitecture):

– this meant simplified hardware,

– a built-in interpreter at the microarchitecture level was interpreting programs at the ISA level.

Invention of the operating system

· Even with microprogramming, working with computers was tedious:

– programs were stored on punch cards (e.g. about 80 for a program),

– the user would have to load the interpreter/translator,

– then load their own program and data.

· Work time had to be booked in advance – computers were complicated machines that had to be operated directly by the programmer.

· Around 1960 the idea of having a program (the operating system) in the computer at all times emerged:

– it led to a new virtual machine that got more and more complicated over the years,

– some of its instructions were similar to those of the ISA level,

– others (in particular I/O) were different (operating system macros, supervisor calls).

Migration of functionality to microcode

· In the 1970s microprogramming was widespread.

· It was common practice to add more and more instructions to the set of machine instructions.

· This led to an explosion of machine instruction sets.

· Examples of instructions added:

– integer multiplication and division,

– floating-point arithmetic,

– calling and returning from procedures,

– speeding up loops,

– handling character strings.

· Examples of added features:

– computations involving arrays,

– memory relocation facilities,

– interrupt system,

– process switching.

· Adding many instructions (not always needed, not always executed) meant that microprograms grew slower, bulkier.

Elimination of microprogramming

· The solution to the problems caused by the large instruction sets devel-oped in the golden years of microprogramming was to reduce vastly the instruction set and have the instructions executed directly by hardware, rather than by a microprogram.

· There are two trends:

– CISC (Complex Instruction Set Computers),

– RISC (Reduced Instruction Set Computers),

– more details discussed later : : :

To summarize...

The evolution of multilevel machines shows how, depending on various fac-tors, the border between hardware and software moves back and forth.

1.2 Milestones in Computer Architecture

Generations of computers

· Generation zero: mechanical computers (1623(?)–1945).

· The first generation: vacuum tubes (1945–1955).

· The second generation: transistors (1955–1965).

· The third generation: integrated circuits (1965–1980).

· The forth generation: very large scale integration (1980 – ?).

· The fifth generation: Japan’s fifth generation computer project (1982 – 1992).

· The next generation?

Generation zero: mechanical computers

· designed to computer tables of numbers for navigation,

· output: punched on a copper plate (CD ROM principle).

– was completing a PhD at Harvard,

– he discovered Babbage’s work and set out to implement his analytical engine using relays instead of toothed wheels,

– Mark I, Harvard 1944 had 72 words of 23 decimal digits each, an instruction time of 6 sec, I/O on punched paper.

Figure 4: The von Neumann design.

· The design was implemented as the IAS machine:

– memory of 4096 words, each of 40 bits (holding either 2 20 bit instructions or 40-bit signed integer, 8 bit instruction type, 12 bit memory address).

– ALU with a 40 bit register - the accumulator,

– typical instructions: add a word from memory to the content of the accumulator, write the content of the accumulator into the memory.

· Whirlwind I, a machine designed for real-time control (as opposed to heavy number crunching like IAS, ENIAC).

16 bit words,

– it lead to the invention of the magnetic core memory (Jay Forrester).

· IBM - initially a producer of punchers and card sorting machines,

started showing interest in computing machines.

– 1953 IBM 701, 2084 36 bit words,

– 1957 IBM 704 4k core memory, 36 bit instructions, floating point hardware,

– IBM 709, an upgrade of the 704.

Transistors (1955-1965)

• Transistors:

Figure 5: The PDP-8 omnibus.

– 1948, AT&T Bell Labs, John Bardeen, Walter Brattain, William Shockley.

– 1965 Nobel Prize for Physics,

· First transistor computers developed at MIT:

– TX-0 (Transistorized eXperimental computer 0) 1956

– TX-2, 1958

· From MIT, a number of team members go on to establish Digital Equip-ment corporation:

– 1961: PDP-1:

· 4 kb of memory, 18 bit words, $ 120,000.

· 512 x 512 points screen,

· Spacewar - one of the earliest games (MIT students).

– 1964: CDC 6600

· CPU able to perform parallel operations twice as fast as 7094,

· small computers inside used to perform I/O operations, sort of like “Snow White and the Seven Vertically Challenged People”. CPU could spend all its time crunching numbers, leaving all the details of job management and I/O to the smaller computers

– IBM PC (1981 - public documentation for $ 49 leading to a PC clone industry),

– Apple, Apple II (Steve Jobs, Steve Wozniak),

– Amiga, Atari.

· Mid 1980’s - RISC processors (replacing CISC processors).

· Mid 1990’s - superscalar CPUs.

The Fifth Generation

· Japan’s fifth generation computers (1982-1992),

Figure 6: Milestones in the development of the digital computer.

1.3 The Computer Zoo

Technological and Economic Forces Driving Computer Development

· The primary force is the ability of chip manufacturers to pack more and more transistors per chip every year:

– Moore’s Law (Gordon Moore, co-founder and chairman of Intel, 1965):

“The complexity for minimum component costs has increased at a rate of roughly a factor of two per year ... Certainly over the short term this rate can be expected to continue, if not to increase. Over the longer term, the rate of increase is a bit more uncertain, although there is no reason to believe it will not remain nearly constant for at least 10 years.”(”Cramming more components onto integrated cir-cuits”, Electronics Magazine 19 April 1965).

– today’s formulation: the number of transistors doubles every 18 months (and it was correct so far).

– the estimation is that it will hold until around 2020 (when physical limits will be reached).

– Moore’s law drives a virtuous circle: better technology ! smaller prices ! more products ! more companies ! better technology.

– Figure 7 illustrates the fact that Moore’s law still holds today.

Figure 7: A representation of Moore’s law (source: commons.wikimedia.org).

– Nathan’s first law of software (Nathan Myhrvold, former top execu-tive, Microsoft):

“software is as gas - it expands to fill the container holding it”.

· Not all computer technologies develop as fast: storage capacity increases only about 50% per year.

· Communications, on the other hand saw spectacular development (high speed Internet).

The computer spectrum

· Several ways of using Moore’s law:

– Increase computer power at constant price.

– Build the same computer for less and less.

– Shrink the size of the hardware for constant power.

· Categories of computers:

Disposable computers

· To the low end, greeting cards, playing cheerful tunes.

· Possibly the most important development: RFID (Radio Frequency IDen-tification) chips:

– smaller than 0.5 mm on edge,

contain a tiny radio transponder and a built-in unique 128 bit number.

– Applications:

· labelling products in stores

· animal ID (pets, farm animals, etc.),

· vehicle tracking (controversial),

· airline luggage,

· cash marking (possible RFID in Euro notes),

Microcontrollers

· Microcontrollers = computers embedded in devices that are not sold as computers.

· They manage the devices and/or user interfaces.

· Found in a large variety of devices:

– Appliances (clock radio, dishwasher, microwave, alarm).

– Communication gear (cordless phones, cell phones, pagers).

– Computer peripherals (printer, scanner, modem, CD ROM drive).

– Entertainment devices (DVD, stereo, mp3 player).

– Imaging devices (TV, digital cameras, photocopier).

– Medical devices (X ray, MRI, digital thermometer).

– Military weapon systems (missiles, etc.).

– Shopping devices (vending machines, ATM).

– Toys (talking dolls, radio-controlled cars, etc.)

· Critical design issues: Price, energy, application-specific performance.

· Example: a car could contain up to 50 microcontrollers (ABS, fuel injec-tion, radio, GPS, etc), a plane more than 200.

· Compared to RFIDs, microcontrollers are complete computers (processor, memory, I/O capabilities).

· Types:

– general purpose - complete computers,

– special purpose (architecture geared to some application, e.g. multi-media) : has instruction set tuned to a specific application.

· General purpose microcontrollers differ from ordinary computers:

– extremely cost sensitive (in large number they may cost as little as $ 0.01 per unit),

– operate in real time (get a stimulus and react to it instantly),

– physical constraints (designed with size restrictions in mind)

Game consoles

· Game consoles - normal computers with special graphics and sound capa-bilities, but limited software and little extensibility.

· Started out as low-end machines (ex. action game like ping pong on TV) but evolved into far more powerful systems (sometimes outperforming personal computers in certain dimensions).

· Examples (last generation): Microsoft XBOX 360, Sony Playstation 3, PSP, Nintendo Wii.

· Other characteristics:

– Customized hardware: special processors, I/O devices.

– Low cost - price supported by manufacturers (consoles sold at a loss, profits from games).

Collections of workstations

· COW - Clusters of Workstations - multiple workstations collected to-gether.

· Special software allows them to work on a single problem.

· The clusters are called many time COTS (Commodity Off The Shelf) machines linked by high-speed networking hardware.

· These scale easily.

· One typical application: Internet Web server - server farms (hundreds, thousands of servers).

· Critical system design issues: Price-performance, throughput, energy pro-portionality.

Mainframes

· In many cases, mainframes are descendants of the IBM 360.

· They are not much faster than a powerful sever, but may have higher I/O capacity, higher storage.

· Very expensive, but many companies find it cheaper to pay once in a while for a mainframe, than update software.

· This has led to the Y2K problem (originating in the 1960-70s when COBOL programmers used only 2 digits for years).

· Andrew Tanenbaum predicts “the end of civilization as we know it at midnight on Dec. 31, 9999, when 8000 years worth of COBOL programs crash simultaneously.”

· Critical system design issues: Price-performance, application-specific performance, throughput, energy proportionality.

1.4 Computer Families

Intel x86 -*

· 1968 - Robert Noyce, Gordon Moore, Arthur Rock form Intel Corporation (and sell $ 3000 worth of chips).

Figure 8: Key members of the Intel family.

Figure 8 gives another summary of the most important members of the Intel family.

UltraSPARC

· 1970’s Unix could only run on minicomputers such as PDP 11;

· 1981 Andy Bechtolsheim SUN 1 (Stanford University Network) a personal computer that would run Unix (Sun Microsystems 1982);

– these workstations (Sun 1, 2, 3) used Motorola CPUs;

– the Sun workstations were more powerful than the PCs of the day and came equipped with an Ethernet connection and TCP/IP software;

· 1987 Sun decides to design its own CPU, based on the revolutionary new design from the University of California at Berkeley (RISC II):

Enters SPARC (Scalable Processor ARChitecture) the basis of Sun 4;

· Various manufacturers produced their own implementation of the open architecture:

– MicroSPARC,

– HyperSPARC,

– SuperSPARC,

– TurboSPARC,

each of the above being compatible with the architecture (running the same programs);

· SPARC International Consortium manages the development of the SPARC architecture;

· The initial SPARC CPU: 32 bit machine 36 MHz, 1986 Sun/Fujitsu;

· 1995 UltraSPARC I: 64 bit architecture, 64 bit address space, 64 bit reg-isters, but still able to run SPARC 32 bit instructions:

– implementing the SPARC V9 specifications,

– instructions designed to handle images, audio – VIS (Visual Instruc-tion Set);

· 1997 UltraSPARC II;

· 2001 UltraSPARC III;

· 2003 UltraSPARC IV;

· 2006 UltraSPARC T1;

· 2007 (late) UltraSPARC T2;

· 2010 (late) SPARC T3.

· 2011 SPARC T4 (Oracle).

· 2013 SPARC T5 (Oracle).

· 2015 SPARC64 XIfx (Fujitsu), SPARCM7 (Oracle).

ARM

· Advanced RISC design, initially Acorn Computer RISC design, later Ad-vanced RISC Machine.

· Timeline:

– 1985: ARM2 (popular in schools UK, Ireland, Australia, New Zealand),

– 1993: ARM 610 (Apple Newton),

– mid 90’s: strongArm (ultrafast - 233MHz, ultra low power - 1W),

– 1994: ARM7 (still used today)

– 2011: 64 bit ARM architecture.

· ARM does not manufacture processors, but licenses them.

· ARM is the most widely used processor (over 50 billion processors by 2015, growing).

· Typical applications: hand-held devices, home appliances, etc.

· Some characteristics: RISC design, low power, hardware support for Java bytecode.

Java

· Sun Microsystems: mid 1990’s designs Java (inspired by C++), aiming at crossplatform compatibility;

· JVM (Java Virtual Machine): memory of 32 bit words, 226 instructions;

· Java programs are compiled for JVM;

· To run compiled Java code on a machine, one needs an interpreter (usually written in C i.e. available virtually everywhere, but generally slow);

· JIT (Just in Time) compilers:

– JVM to machine compilers, usually found in web browsers,

– using a JIT solution may cause delays in execution;

· picoJava II (1998)

– a chip architecture that implements JVM,

– designed for embedded devices (i.e. low cost, way under 50$),

– various implementations available.

These slides are credited to Prof. Adrian Crăciun