Ib computer science computer arch notes

IB Computer Science

Topic 2 Computer Organisation

2.1 Computer Architecture

Computers are electronic devices; fundamentally the gates and circuits of the CPU control the flow

of electricity. We harness this electricity to perform calculations and make decisions. Understanding

the architecture of the computer is almost equal parts Computer Science and equal parts Electrical

Engineering. Before going too deep into this part of the course, it is useful to have a fundamental

understanding of how the binary number system works as this section explores how the computer

use electric signals to represent and manipulate binary values.

Any given electric signal has a level of voltage. As we know binary consists of 2 values, 1 and 0 or

high and low to think of it another way. The tricky thing is representing this in voltage. Computers

consider a signal of between 0 and 2 volts to be “low” and therefore a 0 in binary. The voltage level

between 2 and 5 is considered “high” and therefore is 1.

Gates are devices that perform basic operations on electrical signals. Gates can accept one or more

inputs and produce a single output signal. Several types of gate exist but we will only consider the 6

fundamental types. Each gate performs a particular logical function.

Gates can be combined to create circuits. Circuits can perform one or more complicated tasks. For

example, they could be designed to perform arithmetic and store values. In a circuit, the output

value of one gate often becomes the input for another. The flow of electricity in circuits is controlled

by these gates.

George Boole, a nineteenth century mathematician, invented a form of algebra in which functions

and variables can only have 1 of 2 values (1 and 0). His notation is an elegant and powerful way to

demonstrate the activity of electrical circuits. This algebra is appropriately named Boolean algebra.

A logic diagram is a way of representing a circuit in a graphical way. Each gate is represented by a

specific symbol. By connecting them in various ways we can represent an entire circuit this way.

A truth table defines the function of a gate by listing all possible combinations of inputs and the

output produced by each. The tables can have extra rows added to increase the complexity of the

circuit they represent.

Gates

Gates are sometimes referred to as logic gates as they each perform a single logical operation. The

type of gate determines the number of inputs and the corresponding output.

NOT Gate

This gate takes a single input and gives a single output. Below are three ways to represent the NOT

gate, the truth table (Boolean notation), the logic diagram symbol (real and IB forms) and the

Boolean expression. Note: the input in each case is A and the output is X. The NOT gate simply

inverts the input it is given. As it only has one input, there are only 2 possibilities for input.

Boolean Expression Logic Diagram Symbol Truth Table

X = ‘A

This is acceptable in IB However, the actual symbol is this:

A X

0 1

1 0

AND Gate

This gate differs from the NOT gate in many ways. Firstly it accepts two inputs. Both inputs have an

influence on the output. If both inputs in the AND gate are 1, then the output is 1, otherwise the

output is 0. Note the Boolean algebra symbol for AND is ∙, sometimes an asterisk is used and at other

times the symbol is ignored entirely e.g. X = AB


X = A ∙ B

In IB, this is acceptable But the actual symbol is this

A B X

0 0 0

0 1 0

1 0 0

1 1 1

NOT

AND

OR Gate

Like the AND gate, the OR gate has 2 inputs. If both inputs are 0, then the output is 0. In all other

cases the output is 1. The Boolean algebra symbol for OR is +.


X = A + B

For IB, you can use this: However, the actual symbol is this:

A B X

0 0 0

0 1 1

1 0 0

1 1 1

XOR Gate

The eXclusive OR gate again uses 2 inputs. It behaves only very slightly differently to the OR Gate. It

requires that only one of the inputs be 1 to produce an output of 1. If both are 0, the output is 0, the

same when both inputs are 1. You can see the symbol for XOR is the symbol for OR inside a circle.


X = A ⊕ B

For IB, you can use this: However, the actual symbol is this:

A B X

0 0 0

0 1 1

1 0 1

1 1 0

NAND and NOR Gates

The final 2 gates we will look at are the NOR and NAND gates. Each accepts 2 inputs. They are

essentially the opposite of AND and OR gates respectively. E.g. They take the output produced by

these gates and invert it.

OR

XOR

NAND


X = (A ∙ B)’

For IB you can use this: However, the actual symbol is this:

A B X

0 0 1

0 1 1

1 0 0

1 1 0

NOR


X = (A + B)’

For IB, you can use: Bu the actual symbol is this:

A B X

0 0 1

0 1 0

1 0 0

1 1 0

You can see that there are no specific symbols for NAND and NOR gates in Boolean. We rely on the

AND and OR expressions combined with a NOT to define them. You can also see that the Logic

Diagram Symbols are like hybrids of AND or OR gates with a NOT. In fact, the circle before the output

is known as the inversion bubble.

Outline the architecture of the central processing unit (CPU) and the functions of the arithmetic logic

unit (ALU) and the control unit (CU) and the registers within the CPU.

Circuits

Circuits can be put into 2 categories, combinational and sequential. In a combinational circuit, the

input values explicitly determine the output, in a sequential circuit, the output is a function of the

input values as well as the existing state of the circuit, and so sequential circuits usually involve the

storage of some information.

NOR

NAND

Combinational

Gates are combined into circuits, where the output of one gate is the input to another. Consider the

following diagram:

You can see that the output of the AND gate (D, inputs A, B) is the first input to the OR gate, and the

second input comes from the AND gate (E, inputs A, C). What this means is that for the overall

output to be 1, either A∙B must be 1 or A∙C must be 1. We can represent this in a truth table like so,

because there are three inputs to the system, there are eight possible combinations to consider:

A B C D(A∙B) E(A+B) X(A∙B+A∙C)0 0 0 0 0 0

0 0 1 0 0 0

0 1 0 0 0 0

0 1 1 0 0 0

1 0 0 0 0 0

1 0 1 0 1 1

1 1 0 1 0 1

1 1 1 1 1 1

We can express this truth table as: (A∙B + A∙C)

The Boolean expression for the circuit is an interesting one, and one that we should look at more

carefully. We could actually use some rules to generate an equivalent circuit. That’s the beauty of

Boolean algebra; you can apply provable mathematical rules. These can be used to reduce the

complexity of circuits. We can apply the distributive law:

(A∙B + A∙C) = A∙ (B+C)

AND

AND

OR

AB

C

D

E

X

Thus reducing the circuit to this:

If we look at the truth table for this circuit, it should prove the law:

A B C B+C A∙(B+C)0 0 0 0 0

0 0 1 1 0

0 1 0 1 0

0 1 1 1 0

1 0 0 0 0

1 0 1 1 1

1 1 0 1 1

1 1 1 1 1

The result in column 5, exactly matches the result in the previous truth table, proving the

distributive law. Here are some other laws worth knowing about. You can try to prove them yourself

by creating the truth tables.

Property AND ORCommutative A∙B = B∙A A+B = B+A

Associative (A∙B) ∙C = A∙(B∙C) (A+B) + C = A+(B+C)

Distributive A∙(B+C) = A∙B + A∙C A+(B∙C) = (A+B) ∙ (A+C)

Identity A∙1 = A A+0 = A

Complement A∙(A’) = 0 A+(A’)=1

DeMorgan’s (A∙B)’ = A’ + B’ (A+B)’ = A’ ∙ B’

Adders

The most basic of operations a computer can perform is an addition. Fundamentally, this happens in

binary, and the simplest of additions would be to add two binary digits together. Like addition in any

number bas, there is the potential for a carry to take place. We can draw a truth table for the

addition of two binary values:

A B Sum Carry0 0 0 0

0 1 1 0

1 0 1 0

1 1 0 1

AND

ORA

B C

X

You can see that the sum column is the same as an XOR, whilst the Carry column matches the

pattern for an AND. We can use this to construct the logic diagram for the adder:

This circuit will happily sum two single binary digits, but will not work for binary numbers of more

than one digit as it takes not account of a carry in. It is in fact a half‐adder; we can combine two of

them to create a full‐adder that takes account of a carry in.

It should also be noted that circuits play another important role: they can store information. These

circuits form a sequential circuit, because the output of the circuit also serves as input to the circuit.

E.g. the current state of the circuit is used in part to determine the next state. This is how memory is

created.

Integrated circuits (chips) are pieces of silicon on which multiple gates have been embedded. The

silicon is mounted on plastic and has pins that can be soldered onto circuit boards or inserted into

appropriate sockets. The most important integrated circuit in the computer is the CPU.

The CPU

The CPU is essentially an advanced circuit with input and output lines. Each CPU chip contains

multiple pins through which, all communication in a computer system takes place. The pins connect

the CPU to memory and I/O devices, which at a fundamental level are actually circuits themselves.

Von Neumann Architecture

In 1944‐1945 there was a realisation that the data and instructions needed to manipulate it were

logically the same. This also meant that they could be stored in the same place. The computer design

built upon this principle became known as the von Neumann architecture and is still the basis for

computers today.

In this architecture there are some distinct features:

There is a memory unit that holds both data and instructions

There is an arithmetic/logic unit that is capable of performing arithmetic and logic

operations on data

There is an input unit that moves data from the outside world into the computer

An output unit that can move results from inside the computer to the outside world

There is a control unit that acts like a conductor, ensuring all of components work in concert

XOR

OR

A

B

Sum

Carry

The structure of such a computer might look something like this:

Arithmetic/Logic Unit (ALU)

This unit is capable of carrying out basic arithmetic such as adding, subtracting, dividing and

multiplying 2 numbers. It is also capable of performing logic operations such as AND, OR and NOT.

The ALU operates on ‘words’ a natural unit of data associated with a particular computer design.

Historically, the ‘word length’ of a computer is the number of bits that can be processed at once by

the ALU. It should be noted that Intel now define ‘word length’ as 16 bits and their processors can

work with double words(32 bits) and quadwords(64 bits). We will use ‘word length’ in its traditional

sense.

The ALU also has a small number of special storage units called registers. Registers can store one

word temporarily. For example, consider the following calculation:

(value1 + value2) * (value3 + value4)

We know that the ALU can only deal with 2 numbers at one time, so the outcome of value1 + value2

needs to be stored before the ALU can add value3 and value4. Both outcomes are then required to

do the multiplication. Rather than storing the values in memory and then having to retrieve them

when required, the registers can be used to store the results and then retrieve them as necessary.

Access to registers is much quicker than access to memory.

Control Unit

This is the organising force in the computer, it is in charge of the fetch‐execute cycle (discussed

further on in these notes). The control unit contains 2 special registers as you can see in the diagram,

the PC –program counter and the IR‐ instruction register. The IR contains the current instruction

being executed and the PC the address of the next instruction to be carried out.

Input Output CPU

Cache

Primary Memory

Control Unit Arithmetic

/Logic Unit

MAR MDR

IR PC

Address bus

Data bus

Buses

This diagram shows how a bus is used to allow data to flow through a von Neumann machine.

This is a very simplified view of how buses work. There are a number of different buses connecting

each component. Buses allow data to travel throughout the computer. A bus is a collection of wires,

meaning that if your bus is 16‐bits wide, 16 bits can be transmitted at a single time. If your computer

has a word length of 16 bits, then it is very helpful if your bus is the same width. If the bus was 8 bits

wide for example, it would take two operations to move that data from memory to the ALU.

Buses can carry three types of information: data, address and control. Address information is sent to

memory to tell it where to store data or where to retrieve it from. Address information might also

indicate a device that data should be sent to. Data can then flow to memory and I/O from the CPU.

Control information is used to manage the flow of address and data, typically the direction of the

flow is managed in this way.

Address Bus and Data Bus

Buses are collections of wires through which data can be sent for example:

Single wire: 10011100 Destination

You can see that in order to send an 8‐bit number through a single wire, you would have to do it

sequentially, this means you would have to wait until the last bit arrived. By using a bus, a parallel

group of wires, the data can be sent simultaneously, so it all arrives at the same time:

Bus

1 0 0 1 1 1 0 0

Destination

Input Devices Output Devices Main Memory CPU

Bus

MAR/MDR

These are the Memory Address Register and Memory Data Register respectively. The MAR is where

the CPU sends address information when writing to or reading from memory. The MAR specifies to

memory where the data should go or come from. The MDR is where the CPU sends data to be stored

in memory and where the data being read from memory arrives in the CPU. It may be more useful to

see how these registers play a big part in the stored program concept or Fetch‐Execute Cycle, a little

later in these notes.

Cache

On the diagram you can see an area of cache connected to the CPU. Many modern CPU

architectures make use of cache to speed things up. Cache is a small amount of fast access memory

where copies of frequently used data are stored. This might be values that have been computed

previously or duplicates of original values that are stored elsewhere. The cache will be checked

before accessing primary memory, which is a time consuming process, as the buses tend to slow

things down. The CPU will check the cache to see whether it contains the data required, if does then

we get a cache hit and access to data without using the buses. If it doesn’t then access to primary

memory becomes a necessity.

RAM or ROM?

As mentioned previously, RAM and primary memory are considered to be the same thing. RAM

stores programs and data whilst they are in use by the CPU; otherwise they are kept in secondary

storage (hard disk). RAM is memory in which each location can be accessed, as well as being able to

access each location; the contents can also be changed.

You may want to visualise RAM like so:

Address Content

000 Instruction

001 Instruction

010 Instruction

011 End

100 Data

101 Data

Of course the data and instructions would be stored as binary, but you can see that the instructions

are stored contiguously and the data in a separate section of memory. This is helpful in the machine

instruction cycle, as we can simply increment the pointer that keeps the place of the next instruction

to be executed.

The address is used to access a particular location in RAM, so the CPU needs to pass this information

when it wants to read a location, and when it wants to write to a location.

ROM has very different behaviour to RAM. ROM stands for Read Only Memory; this means that the

contents of ROM cannot be altered. The content of ROM is permanent and cannot be changed by

stored operations. The content of ROM is ‘burned’ either at the time of manufacture or when the

computer is assembled.

RAM and ROM also differ in another basic property, RAM is volatile, and ROM is not. This means that

whatever is in the contents of RAM when the computer is switched off, will not be there when it is

restarted. ROM retains its contents even when the machine is turned off. Because ROM is stable it is

used to store the instructions that the computer needs to start itself (bootstrap loader). Other

frequently used software can be stored in ROM so that it does not have to be read into memory

each time the machine is turned on.

Primary memory is usually made up of a combination of both RAM and ROM.

Machine Instruction Cycle

A computer is a device that can store, retrieve and process data (remember the fundamental

operations). Therefore all of the instructions it is given relate to these three operations. The

underlying principle of the von Neumann machine is that data and instructions are stored in memory

and treated alike. This means that both are addressable (see notes on primary memory). Instructions

are stored in contiguous memory locations; the data to be manipulated is stored in a different part

of memory. To start the Machine Instruction Cycle (Fetch‐Execute Cycle) the address of the first

instruction is loaded into the Program Counter. The cycle then follows 4 steps:

Fetch the next instruction

Decode the instruction

Get data if needed

Execute the instruction

Of course each of these is an abstraction of what actually takes place, so let’s look at each in a little

more detail.

Fetch the next instruction

The PC contains the address of the next instruction to be executed. So the address from the PC is

loaded into the MAR in order to access that location in memory, the address information travels

along the address bus to main memory. The control unit tells memory that the CPU wishes to read

the instruction at the address specified by the address bus. Primary memory accesses the contents

of that memory location and sends the data to the CPU along the data bus. It arrives in the MDR

where it is quickly passed to the Instruction Register to be decoded. Before decoding takes place, the

Control Unit updates the address held in the PC to ensure it is for the next instruction.

Decode the instruction

In order to execute the instruction held in the IR, it first must be decoded to determine what it is. It

could be an instruction to access data, from an input device, send data to an output device or to

perform an operation on a value. The instruction is decoded into control signals. The logic circuitry in

the CPU determines which operation is to be executed. This shows why a computer can only execute

machine language instructions that are written in its own native language.

Get Data if needed

If the instruction is to use the contents of a certain memory location and add them to the contents

of a register, memory will have to be accessed again to get the contents of the memory location.

Execute Instruction

After being decoded and any data that is needed is accessed, the instruction can be executed.

Execution usually involves the control unit sending signals to the appropriate part of the CPU or

system. For example if the instruction is to add the values stored in 2 registers, the CU sends a signal

to the ALU to do so. The next instruction might be to store the result in a register or even a memory

location. After execution, the next instruction is fetched and the process begins all over again, until

the last instruction has been executed.

A useful animated version of the Machine Instruction Cycle can be found here:

Persistent Storage

There are a few other terms by which Persistent Storage might be known: backing

storage/secondary storage. They all refer to the same thing, a place where programs and data can

be stored when they are not being processed or the machine is turned off. As data is read from and

written to these devices, they could also be considered input and output devices. There are several

types of persistent storage, the most popular is the hard‐disk, usually installed by the manufacturer,

and the typical size of these nowadays is 500GB‐1TB. Let’s look at the hard‐disk first.

The hard disk has several moving parts. The disk itself has to spin at between 5400rpm‐7200rpm, the

small delay that you experience when accessing the hard‐disk after an idle period is the time it takes

for the disk to reach the required speed. The disk is made of magnetic material and the data is

represented by magnetic charge (positive and negative charge lends itself nicely to our binary

system of 2 states). Above the disk (platter) is a read/write head. It is fixed at one end and can move

from the outside of the disk to the inside. The disk spins underneath to get the data required

underneath the read/write head. With the speed of the disk and the read/write head about the

width of hair away from it, you can understand how any violent movement could damage or corrupt

the disk.

The disk itself is divided up by sectors and tracks. This creates blocks; you can choose the size of

these blocks when you format a hard‐disk. The diagram on

the right illustrates the division of the disk. The red section

is a track; the yellow section is a block, created by the

further division of the disk into sectors. It should be noted

that this division is not a physical one, these lines are not

scored on the disk; they are magnetic. This means we can

re‐format disks to use different file formats or to create

smaller or larger blocks.

In order to provide the storage required

for today’s computer users very often a

hard disk contains several platters each

with their own read‐write head. These

platters are stacked with little space

between them. The diagram illustrates

this arrangement. You can also see that

both sides of the platter are utilised.

In relation to the speed at which the CPU

works, accessing the hard disk and the

data therein is slow. This is due to a

couple of factors. Firstly, the read‐write head needs to be positioned over the correct track, this is

called seek time. The disk then needs to spin in order to get the correct sector under the read‐write

head, called latency. The sum of latency and seek time is what we call access time, the time it takes

for data to start being read. After we begin reading data there is of course the transfer rate, which is

the rate at which data moves from the disk to memory. This is usually measured in Mbps (Mega‐bits

per second. Note: b = bits, B = bytes)

Solid state disks (SSD) are gaining more prominence, they have no moving parts so are considered to

be more robust than traditional hard‐disks. They also come with the benefit of less power

consumption, highly beneficial as computing moves ever more mobile, and they are faster. SSDs use

electrical signals, gates and transistors to store data. How they work is beyond the scope of the

course, but if you have an interest in how they work you can find out more here.

Older Persistent Storage

Some older technologies for persistent data storage include punch cards and paper tape. A more

recent and sometimes still used technology is magnetic tape. A lot of back‐up copies of servers are

still committed to magnetic tape. Like hard disks, magnetic tape is read/written by passing through a

read/write head. One of the drawbacks is that the data is stored and accessed sequentially. In other

words, if you want to access a piece of data in the middle of the tape, you need to go through all the

data that precedes it. More modern tape systems have functions to overcome this however, they

can skip sections of the tape, but the tape must still pass through the read‐write head.

Operating System

Software can be divided into 2 categories, application software and systems software. Application

software is written to address specific needs – to solve real world problems. Systems software

manages a computer system at a more fundamental level. System software usually interacts directly

with hardware and provides more functionality than the hardware itself does.

The operating system is at the core of system software. It manages computer resources such as

memory and I/O devices and provides the interface through which we as humans interact with the

computer. The following diagram shows how the OS is positioned and related to all other aspects of

the computer system.

The operating system manages hardware resources and

allows application software to access system resources

either directly or through other systems software. It also

provides access to the computer system via an interface.

This interface has evolved in look and input devices over

time. If we look at MS‐DOS, the pre‐cursor to Windows,

you can see it is a command drive interface. This meant

that in order to use a computer, you had to learn at

least a basic set of commands, this made them inaccessible to most people as they did not have the

desire to invest the time necessary to use them proficiently for personal use.

Human Users

Application Software

Operating System

Other systems software

Hardware

This style of OS then evolved with the creation of the

mouse. Users could point to things and click on them,

this was a different, easier way to interact with the

system. Windows XP is an example of the how the OS

has evolved. To begin with, Windows was simply an

interface for MS‐DOS but more recent versions have

moved away from this but still use DOS as part of the

bootstrap system. This style of OS is often referred to as

a WIMP environment (Windows Icons Menus Pointers).

Of course the biggest change since the idea of GUI first appeared is the input devices we use. Touch

is almost ubiquitous in smartphones nowadays but the idea of gesture is gaining traction too,

especially low power consuming versions of gesture control. This has led to a change in the design of

the GUI for operating systems, where icons for apps use a skeuomorphism approach.

Smartphones run versions of operating systems that are tailored to their needs. For example, they

have more constraints on memory use, power consumption and a smaller set of peripherals to deal

with. Apple products run iOS which is derived from Mac OS. Android devices run the open source OS

developed by Google, and is the most popular OS for hand held devices.

Any given operating system manages resources in its own way. The goal for you is to understand the

common ideas that apply to all operating systems.

If you are interested in the development and evolution of Operating Systems then read more here:

http://en.wikipedia.org/wiki/History_of_operating_systems

Multiprogramming, Memory Management and CPU Scheduling

Operating systems have developed to allow multiple programs to reside in main memory at any one

time. These programs compete for use of the CPU so that they can do what they need to do. This has

created the need to manage memory to keep track of what programs are in memory and where they

are.

A key concept when referring to the OS is the idea of a process. A process is simply a program in

execution. The process is a dynamic entity that represents the program whilst it is being executed. A

process has a lifecycle, presented as a chart below:

The OS must manage these processes carefully; there might be many active processes open at once.

If you open your task manager or equivalent, you will see which processes are active on your

computer. As you can see, some processes might need input or to output, they may also need to

wait on the results of some calculation. A process might also be interrupted during its execution.

Think about playing Angry Birds on the MTR, if you get a call on your phone, the game will pause and

you will be prompted to either answer or reject the call. This is an example of an interrupt, and

Angry Birds becoming a process in “waiting”.

Related to these management issues is the need for CPU scheduling, this determines which process

will be executed at any point in time.

Memory Management

As mentioned earlier, multiple programs and their data will reside in memory at the same time, this

gives us multi‐programming. Therefore, the OS needs to be able to:

Track how and where programs reside in memory

Convert logical addresses into physical addresses

As we know from our programming experience, programs are filled with references to variables and

to other parts of the code. When the program is compiled, these references are changed to actual

addresses in memory where the data and code reside. Given that the compiler has no control over

where in memory a program could end up, how will it know what address to use for anything?

To overcome this, programs will need two kinds of address. A logical address (sometimes called a

relative address). This specifies a location relative to the rest of the program but is not associated

with main memory. A physical address refers to an actual location in main memory. When a program

is compiled, references are changed to logical addresses. When the program is eventually loaded

into memory, logical addresses are translated into physical addresses. This mapping is called address

binding. Logical addresses mean that a program can be moved around in memory, as long as we

keep track of where the program is stored, the physical address can always be determined.

Let’s look at how this might work in a technique known as single contiguous memory management.

If we imagine main memory divided into 2 sections:

This method of management is so‐called because the entire application is loaded into on large chunk

of memory. To carry out address binding, all we need to do is take the operating system into

consideration.

Remember, the logical address (in our example denoted as L) is simply an address relative to the

start of the program. So these logical addresses are created as if the program is loaded at location 0

in memory. To create a physical address, we add the logical address to the physical address.

To be more specific, the OS in our example takes up the first section of memory, and the application

is loaded at location A. We simply add the logical address to this value to give us the physical address

(A+L) in the diagram. If we are even more specific, suppose the program is loaded at address 3000.

When the program uses relative address 2000, it would actually be referring to address 7000 in

physical terms.

It doesn’t matter what address L is, as long as we kept track of A, we can always translate the logical

address into a physical one. Of course, you might think, why not swap the OS and the application

around so that it is loaded at 0, then the logical and physical address is the same. This is true but

presents security issues, the application program might then try to access a location that is part of

the OS and corrupt it, either by accident or maliciously. With the OS loaded where it is, all logical

addresses for the application are valid, unless it exceeds the bounds of memory.

This method of management is simple to implement but inefficient. It wastes memory space as the

application is unlikely to need all of the memory allocated.

Partition Memory Management

The previous technique does not really allow for multi‐programming. This technique addresses this.

Applications need to share memory space with the OS and other applications. Memory can be

partitioned into different portions. The size of these portions can be fixed or dynamic. If they are

fixed, they do not need to be the same size, but the partitions are fixed at boot time. A process is

loaded into a partition big enough to hold it. It is up to the OS to keep track of where partitions start

and how long they are. Using dynamic partitioning, the partitions are created to fit the process that

they will hold. The OS will keep a table of where partitions start and their length, but the values will

change all the time as programs come and go.

OS

Application

program

A

A+L

As with the contiguous approach, each of the programs being executed has its own logical

addresses. The address binding technique is slightly different. The value A in this case is taken from

the table that the OS maintains about where partitions begin. Let’s imagine that process 2 becomes

active. The start of that partition is retrieved from the table and loaded to a special register called

the base register. The value for the length of the partition is stored in another register called the

bounds register. When address binding takes place, the physical address is first compared to the

bounds register to make sure the address is not outside the partition, if it is not, the physical address

is calculated by adding the value for the logical address to the value in the base register.

There are 3 approaches to partition selection:

1. First fit – allocate to the first partition that it fits inside, works well in fixed partitioning

2. Best fit – allocate to the partition that is closest in size to the process(or smallest enough to

hold it), works well in fixed partitioning, but in dynamic, it leaves small gaps that are not big

enough to accommodate any other processes

3. Worst fit – the process is allocated to the largest portion big enough to hold it. This works

well in dynamic partitioning, as it leaves gaps big enough to be usable by other programs

later on.

OS

Process 1

Empty

Process 2 A

A+L

Paged Memory Management

This places more of a burden on the OS to keep track of allocated memory and to resolve addresses.

There are many benefits to this approach and these are generally worth the effort.

In this technique, main memory is divided into small fixed size blocks called frames. A process is then

divided into pages, and we’ll assume these pages are the same size as a frame. When a program is to

be executed, it is distributed to unused frames throughout memory. This means they may be

scattered around and even out of order. To keep track of what is going on, the OS needs to keep a

page‐map table for each process. It matches a page to the frame it is loaded in. The diagram below

illustrates this.

Process 1 PMT

Page Frame

0 5

1 12

2 8

3 22

Memory

Frame Content

0 P2/Page 3

1

2

3

4 P2/Page 0

5 P1/Page 0

6

7 P2/Page 1

8 P1/Page 2

9

10

11

12 P1/Page 1

13 P2/Page 2

Process 2 PMT

Page Frame

0 4

1 7

2 13

3 1

4 31

Address binding is a more complex process in this system. As in the previous methods, the logical

address is an integer relative to the start of the program. This address needs to be modified into 2

values: a page number and an offset. The page number can be created by dividing the logical

address by the page size. The page number is the number of times the logical address can be

divided, the offset is the remainder. So if we take a logical address of 2301, where the page size is

1024. The page number is 2 and the offset 53(2301/1024 = 2 r 53). To create a physical address, the

page number is looked up in the PMT to find the frame number in which it is stored. You would then

multiply the frame number by the page size and then add the offset. So taking our previous example

where the logical address was converted to <<2, 53>>. Let’s assume this refers to Page 2 of Process 2

above. Page 2 of process 2 is stored in Frame 13 of memory. So to get the physical address of where

this is in memory we need to multiply by the size of the frames by the number of frames (1024 * 13

= 13,312) we then add the offset to this value (13,312 + 53 = 13,365). Therefore, the physical address

of <<2, 53>> referring to Page 2 in process 2 is 13,365.

The advantage of paging is that processes no longer need to be stored contiguously in memory and

the process of finding available memory space is made easier as it is about finding lots of small

chunks instead of having to find one large one to accommodate the entire process.

Process Management

The OS must manage the use of the CPU by individual processes. To understand how this works, we

must first appreciate the stages that a process goes through during its computational life. Processes

move through specific states as they are managed. A process enters the system, is ready to be

executed, is executing, is waiting for a resource, or is finished. The diagram below depicts this

lifecycle:

A process with nothing preventing it’s execution is in the ready state. A process in this state is not

waiting on an event to occur or data to be brought from secondary memory. It is waiting on it’s

chance to use the CPU.

A process that is executing/running is using the CPU. The instructions in the process are being

executed by the fetch‐execute cycle.

A process in the waiting state is waiting for other resources, e.g. not the CPU. It may be waiting on a

page to be brought into primary memory from secondary memory or another process to pass it a

signal that it can continue.

A process in a terminated state has completed execution and is no longer active. The OS no longer

needs to keep information regarding the process.

Process management is very closely linked to CPU scheduling, processes can only be in the running

state if they can use the CPU. While running, a process may be interrupted by the OS to allow

another process an opportunity on the CPU. In that case the process simply returns to the ready

state. Alternatively, a running process might request a resource or require I/O to retrieve data or a

newly referenced part of the process from secondary memory, in this case it moves to the waiting

state.

CPU Scheduling

This is the act of determining which of the processes in the ready state should be moved to the

running state. Algorithms to schedule this process make this decision.

CPU scheduling decisions take place when a process moves from the running state to the waiting

state, or when it termintates. This type of scheduling is termed “non‐preemptive scheduling”, this is

because the new CPU process results from the activity of the currently executing process. CPU

scheduling should also take place when a process moves from the running state to the waiting state

or the ready state. This is called “preemptive scheduling” as the currently executing process(through

no fault of its own) is preempted by the OS.

Turnaround Time

Scheduling algorithms are often evaluated using metrics, such as turnaround time for a process. This

is the amount of time between when a proess arrives in the ready state and whn it exits the running

state for the last time. On average, the smaller this value the better.

Several different algorithms exist for the determination of which process should be chosen first to

move to the running state. We will look at 3 and try to evaluate using turnaround time.

First Come, First Served

This operates like a queue. The processes are given CPU time in the order that they arrive in the

running state. They retain access to the CPU unless it makes a request to a resource that forces a

wait. This type of scheduling is non‐preemptive

If we represent this as a Gantt type chart to show when processes are executed it would look

something like this:

140 215 535 815 940

P1 P2 P3 P4 P5

For the purposes of this example, let us assume that all processes arrive at 0. Therefore, the average

time for them to move from ready to complete is (140+215+535+815+940 / 5 = 529)

Shortest Job Next

This algorithm looks at all the processes in the ready state and allows the process with the smallest

service time to execute. It is also a non‐pre‐emptive algorithm. If we use the same set of processes

as before for this algorithm, we will see the effects that this method of scheduling has:

75 200 340 620 940

P2 P5 P1 P4 P5

Process Service Time

P1 140

P2 75

P3 320

P4 280

P5 125

If we work out the average turnaround time in this instance (75+200+340+620+940 / 5 = 435). This is

significantly better than the previous algorithm; however, there are some issues to consider. This

algorithm relies on knowledge of the future. Essentially the OS estimates the time that a process will

take based on the type of job and some other factors. If these estimates are wrong, the premise of

the algorithm breaks down and the efficiency deteriorates. The algorithm is provably optimal,

meaning that if we knew the service time of each job, the algorithm would produce the shortest

turnaround time of all the algorithms we will consider.

Round Robin

This algorithm distributes processing time equally among all processes. The algorithm relies on time‐

slicing (a time slice is the amount of time the process receives before being returned to the ready

state). The algorithm is pre‐emptive, it returns processes to the ready state to give the next process

its time‐slice. This continues until each process gets enough CPU time to be completed and

terminates.

Let us assume that a time‐slice is 50 and we use the same processes as the previous example

50 325 515 640

920

940

P1 P2 P3 P4 P5 P1 P2 P3 P4 P5 P1 P3 P4 P5 P3 P4 P3 P4 P3 P4

P3

Each process is given a time slice of 50, unless it doesn’t need it. Process 2 needed 75 units,

therefore on its second time slice, will only require half the time and so terminates at 325. The

average turnaround time here is (325 + 515 +640 + 920 + 940 /5 = 668) this is significantly worse that

the other algorithms. This does not mean it is the worst of the three, which would be too general a

claim based on a specific set of processes.

The round robin algorithm is one of the most widely used; it supports all kinds of jobs and is

considered the most fair.

Application Software

Application software is all the computer software that causes a computer to perform useful tasks

beyond the running of the computer itself. You have experience of using these on an almost daily

basis, from browsers to word processors, email clients to image editing. These applications are

designed to help the user to perform singular or multiple related specific tasks. This software usually

costs money, however there is a movement in the online community to provide free, open‐source

programs. These programs are often more limited than their paid for counterparts but the fact they

are open‐source means the community to embellish and improve them and re‐distribute for public

use.

The user interface controls how you enter data or instructions and how information displays on the

computer screen. Many of today’s software programs have a graphical user interface (GUI). A GUI

combines text, graphics, and other visual images to make software easier to use. As mentioned

previously, this can sometimes be called a WIMP environment (Windows Icons Menus Pointers).

Many of today’s applications could also be considered WYSIWYG (Whizzy Wig). Dreamweaver is a

prime example of this. You drag and drop items and place them on the page where you think you

want them to go in your web page. Dreamweaver then generates the HTML to make this happen.

When you view the webpage in a browser, it normally looks the same as it did in Dreamweaver

(What You See is What You Get).

There are lots of common features in today’s applications. Consider the following screenshots:

The above is taken from Microsoft Word and shows the menus and toolbars. Let’s consider a

different application from a different vendor:

This is from Photoshop CS6, and although the specific menus have different names, this feature and

layout is very similar to MS Word. We have the menus along the top, with a toolbar underneath. The

menus present commands for the user to select with the mouse pointer (previously these

commands would need to have been remembered and entered using the keyboard). Expert users

might make use of keyboard shortcuts to avoid the sometimes laborious process of navigating

through menus and sub‐menus. The toolbar provides a set of buttons, these buttons are usually

designed to give a clue as to what function they perform e.g. the Print icon is of a printer. These

buttons are created to give access to the most often used commands.

Another area of similarity is the use of windows/dialogue boxes. The 2 images below show the

similarity in the use of windows in the Windows and Mac OS respectively.

Windows and dialog boxes present the user with icons or buttons to select files or choose options.

These choices are made using the mouse/pointing device. Previously, the user would have had to

use commands to navigate through the file structure to find files to open or to choose a location in

which to save a file.

There are obvious benefits to the common features of application software. If a user becomes an

expert in one piece of software, they should be able to go to another application and figure out

where they can look for most used commands and find different options in the menus. Compare this

to command driven software; firstly, the user would need to learn all the commands. If they then

moved on to another piece of software some of the commands might be the same as we have seen

in the screenshots previously, but there would be new ones that would have to be learned. Using

menus, the user can experiment and have access to all of the options by navigating through them.

The common features of these applications make things easier for the “everyman” the non‐expert

who wants to use a computer but doesn’t have the time or desire to invest in becoming an expert

user.

Documents

Ib computer science computer arch notes