EXPERIMENT NO: 01
PROBLEM STATEMENT:
Write a program to convert decimal number to binary and vice versa.
THEORY:
A number system is a systematic way to represent numbers with symbolic characters
and uses a base value to conveniently group numbers in compact form. The most
common number system is decimal, which has a base value of 10, and a symbolic
character set of 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. However, there are other number
systems, and they can be more efficient to use for a specific purpose. For example,
following table shows different number systems:
NUMBER SYSTEM BASE VALUE SYMBOLIC CHARACTER SET
Binary 2 0,1
Octal 8 0, 1, 2, 3, 4, 5, 6, 7
Decimal 10 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9
Hexadecimal 16 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
ALGORITHM:
Conversion of Decimal to Binary-
Step 1 - Divide the decimal number by 2
Step 2 - Get the remainder from Step 1 as the rightmost digit (least significant digit)
of binary number.
Step 3 - Divide the new quotient by 2.
Step 4 - Record the remainder from Step 3 as the next digit (to the left) of the binary
number.
Step 5: Repeat Steps 3 and 4, until the quotient becomes zero in Step 3.
EXAMPLE
Decimal Number: 2910
Calculating Binary Equivalent:
Step Operation Result Remainder
Step 1 29 / 2 14 1
Step 2 14 / 2 7 0
Step 3 7 / 2 3 1
Step 4 3 / 2 1 1
Step 5 1 / 2 0 1
As mentioned in Steps 2 and 4, the remainders have to be arranged in the reverse
order so that the first remainder becomes the least significant digit (LSD) and the last
remainder becomes the most significant digit (MSD).
Decimal Number: 2910 = Binary Number: 111012.
Conversion of binary to Decimal-
Step 1 - Determine the positional value of each digit (this depends on the position of
the digit and the base of the number system).
Step 2 - Multiply the obtained positional values (in Step 1) by the digits in the
corresponding position.
Step 3 - Sum the products calculated in Step 2. The total is the equivalent value in
decimal.
EXAMPLE
(11101001)2
1×27+1×2
6+1×2
5+0×2
4+1×2
3+0×2
2+0×2
1+1×2
0
= (233)10
CONCLUSION:
Implementation of Binary to Decimal and Decimal to Binary conversion performed
successfully.
EXPERIMENT NO: 02
PROBLEM STATEMENT:
Write a program to implement multiplication of two unsigned binary numbers.
THEORY:
Compared with addition and subtraction, multiplication is a complex operation,
whether performed in hardware or software. Multiplication of two unsigned number is
done as follows:
1. The partial products are easily defined. When the multiplier bit is 0, the partial
product is 0.When the multiplier is 1, the partial product is the multiplicand.
2. Multiplication involves the generation of partial products, one for each digit in
the multiplier. These partial products are then summed to produce the final
product.
3. The total product is produced by summing the partial products. For this
operation, each successive partial product is shifted one position to the left
relative the preceding partial product.
4. The multiplication of two n-bit binary integers results in a product of up to 2n
bits in length.
Example :
Figure shows a possible implementation employing these measures. The multiplier
and multiplicand are loaded into two registers (Q and M). A third register, the A
register, is also needed and is initially set to 0. There is also a 1-bit C register,
initialized to 0, which holds a potential carry bit resulting from addition. The
operation of the multiplier is as follows. Control logic reads the bits of the multiplier
one at a time. If Q0 is 1, then the multiplicand is added to the A register and the result
is stored in the A register, with the C bit used for overflow. Then all of the bits of the
C, A, and Q registers are shifted to the right one bit, so that the C bit goes into A n-1
and A0 goes into Qn-1 goes into and is lost. If Q0 is 0, then no addition is performed,
just the shift. This process is repeated for each bit of the original multiplier. The
resulting -bit product is contained in the A and Q registers.
The flowchart for unsigned binary multiplication is as follows:
CONCLUSION:
The program to perform multiplication of two binary numbers was performed and
output obtained.
EXPERIMENT NO: 03
PROBLEM STATEMENT:
Write a program to implement multiplication of 2, two’s complement numbers using
Booth’s algorithm.
THEORY:
Booth's multiplication algorithm is a multiplication algorithm that multiplies two
signed binary numbers in two's complement notation. The algorithm was invented
by Andrew Donald Booth in 1950 while doing research
on crystallography at Birkbeck College in Bloomsbury, London. Booth used desk
calculators that were faster at shifting than adding and created the algorithm to
increase their speed.
Booth's algorithm examines adjacent pairs of bits of the N-bit multiplier Y in
signed two's complement representation, including an implicit bit below the least
significant bit, y-1 = 0. For each bit yi, for i running from 0 to N-1, the bits yi and yi-
1 are considered. Where these two bits are equal, the product accumulator P is left
unchanged. Where yi = 0 and yi-1 = 1, the multiplicand times 2i is added toP; and
where yi = 1 and yi-1 = 0, the multiplicand times 2i is subtracted from P. The final
value of P is the signed product.
The representation of the multiplicand and product are not specified; typically, these
are both also in two's complement representation, like the multiplier, but any number
system that supports addition and subtraction will work as well. As stated here, the
order of the steps is not determined. Typically, it proceeds from LSB to MSB, starting
at i = 0; the multiplication by 2i is then typically replaced by incremental shifting of
the P accumulator to the right between steps; low bits can be shifted out, and
subsequent additions and subtractions can then be done just on the highest N bits
of P.[1]
There are many variations and optimizations on these details.
The algorithm is often described as converting strings of 1's in the multiplier to a
high-order +1 and a low-order –1 at the ends of the string. When a string runs through
the MSB, there is no high-order +1, and the net effect is interpretation as a negative of
the appropriate value.
Flow Chart/Diagram of Booth's Algorithm of Multiplication:-
Example of Booth's Multiplication Algorithm:-Multiply 7 with 3 with the help of
Booth's Algorithm.
Result= AQ = (0001 0101)2 = (21)10
CONCLUSION:
The program to perform multiplication of two signed numbers using Booth’s
Algorithm was performed and output obtained.
EXPERIMENT NO: 04
PROBLEM STATEMENT:
Write a program to implement division of two unsigned numbers using Restoring
algorithm.
THEORY:
The division operation consists of a series of subtractions of the divisor from the
partial remainder, which are only executed if the divisor is smaller than the partial
remainder, when the digit of the quotient is 1; otherwise, the corresponding digit of
the quotient is 0. Consider the division of two numbers: 147 / 11
Flow chart for Restoring division algorithm
Restoring Division Example: 14/3
Result is
Remainder in A= (0010)2 = (2)10
Quotient in Q= (0100)2 = (4)10
CONCLUSION:
Implementation of multiplication using restoring Algorithm was performed
successfully and output obtained.
EXPERIMENT NO: 05
PROBLEM STATEMENT:
Write a program to implement division of 2, two’s complement numbers using non
restoring algorithm.
THEORY:
This algorithm works for both positive and negative number division. In this, we have
to represent dividend and divisor in two’s complement number.
Example
Dividend (A) = 1001, i.e. 7, and Divisor (B) = 0011, i.e. 3.
Initialization:
Set Register A = Dividend = 1111
Set Register Q = Dividend = 1001 (So AQ =1111 1001)
Set M = Divisor = 0011, M' = 2's complement of M = 1101
Set Count =4, since 4 digits operation is being done here.
After this we start the algorithm, which is shown below:
A Q Action
1111 1001 Initial state
1111 0010 Left shift A, Q
+0011
0010 0010 A=A+M (A and M have different signs)
1111 0010 Restore A and Q0=0 ------- cycle 1
1110 0100 Left shift A, Q
+0011 0100
0001 0100 A=A+M (A and M have different signs)
1110 0100 Restore A and Q0=0 ------- cycle 2
1100 1000 Left shift A, Q
+0011
1111 1001 A=A+M (A and M have different signs)
1111 1001 set Q0=1 ------- cycle 3
1111 0010 Left shift A, Q
+0011
0010 0010 A=A+M (A and M have different signs)
1111 0010 Restore A and Q0=0 ------- cycle 4
Result is:
Remainder is in A= (1111)2 = (-1)10
Quotient = Two’s complement of Q = (1110)2 = (-2)10
ALGORITHM:
Step 1: Load the divisor into M register and dividend in A, Q registers. The dividend
must be expressed as 2n bit two’s complement number. For ex: 4 bit 0111 becomes
0000 0111 and 1011 becomes 1111 1011.
Step 2: Left shift A, Q by 1 bit.
Step3: If M and A have the same signs, perform A=A-M otherwise A=A+M.
Step 4: The Preceding operation is successful if the sign of A is the same before and
after the operation.
(a) If the operation is successful or A=0 then set Q0=1.
(b) If the operation is unsuccessful and A!=0 then set Q0=0 and restore the
previous value of A.
Step 5: Repeat steps 2 to 4 as many times as there are bit positions in Q.
Step 6: Remainder is in A. If the signs of the divisor and dividend were the same,
then the quotient is in Q; otherwise the correct quotient is the two’s complement of Q.
CONCLUSION:
The program to perform multiplication of two numbers using restoring Algorithm was
performed and output obtained.
EXPERIMENT NO: 06
PROBLEM STATEMENT:
Implementation of FIFO page replacement policy of virtual memory.
THEORY:
Regardless of the resident set management strategy, there are certain basic algorithms
that are used for the selection of a page to replace in main memory. General page
replacement algorithms
include-
First-in-first-out (FIFO)
Least recently used (LRU)
Optimal
The first-in-first-out (FIFO) policy:
It treats the page frames allocated to a process as a circular buffer, and pages are
removed in round-robin style. All that is required is a pointer that circles through the
page frames of the process. This is therefore one of the simplest page replacement
policies to implement. The logic behind this choice, other than its simplicity, is that
one is replacing the page that has been in memory the longest: A page fetched into
memory a long time ago may have now fallen out of use. This reasoning will often be
wrong, because there will often be regions of program or data that are heavily used
throughout the life of a program. Those pages will be repeatedly paged in and out by
the FIFO algorithm. In the below example, FIFO policy results in six page faults.
Note that LRU recognizes that pages 2 and 5 are referenced more frequently than
other pages, whereas FIFO does not.
Example:
ALGORITHM:
FIFO – First in first out
1. Accept frame size(fno), Number of pages(count) and sequence of
pages(arr[100]) from user
2. Create circular linked list whose size is equal to frame size
3. Initialize each node’s data = -99
4. Call create function for CLL
5. When inserting data in a frame check whether
a. Page number is already present or not
b. There is empty location or not
6. If page is present then don’t take any action, and read next page
7. But if page is not present then we have to insert page in LL
8. If Linked List have empty node then goto step 7
9. If Linked List doesn’t have empty node then overwrite on the oldest node
10. stop
CONCLUSION:
We studied FIFO page replacement algorithm and implemented successfully.
EXPERIMENT NO: 07
PROBLEM STATEMENT:
Implementation of LRU page replacement policy of virtual memory.
THEORY:
Regardless of the resident set management strategy, there are certain basic algorithms
that are used for the selection of a page to replace in main memory. General page
replacement algorithms
include-
First-in-first-out (FIFO)
Least recently used (LRU)
Optimal
The least recently used (LRU) policy:
It replaces the page in memory that has not been referenced for the longest time. By
the principle of locality, this should be the page least likely to be referenced in the
near future. And, in fact, the LRU policy does nearly as well as the optimal policy.
The problem with this approach is the difficulty in implementation. One approach
would be to tag each page with the time of its last reference; this would have to be
done at each memory reference, both instruction and data. Even
if the hardware would support such a scheme, the overhead would be tremendous.
Alternatively, one could maintain a stack of page references, again an expensive
prospect.
Figure shows an example of the behavior of LRU, using the same page address stream
as
for the optimal policy example. In this example, there are four page faults.
Example:
ALGORITHM:
LRU - Least Recently Used
1. Start
2. Declare the size of frame
3. Get the number of pages to be inserted
4. Get the sequence of pages
5. Declare counter and stack
6. Select the least recently used page by counter value
7. Stack them according the selection.
8. Display the values
9. Stop
CONCLUSION:
We studied LRU page replacement algorithm and implemented successfully.
EXPERIMENT NO: 08
PROBLEM STATEMENT:
Implementation of memory allocation algorithms.
1. First – Fit
2. Best – Fit
3. Worst Fit
Theory:
Memory compaction is time consuming; the operating system designer must be clever
in deciding how to assign processes to memory (how to plug the holes). When it is
time to load or swap a process into main memory, and if there is more than one free
block of memory of sufficient size, then the operating system must decide which free
block to allocate.
Four placement algorithms that might be considered are best-fit, first-fit, worst-fit and
next-fit. All are limited to choosing among free blocks of main memory that are equal
to or larger than the process to be brought in. Best-fit chooses the block that is closest
in size to the request. First-fit begins to scan memory from the beginning and chooses
the first available block that is large enough. Next-fit begins to scan memory from the
location of the last placement, and chooses the next available block that is large
enough. Worst-fit chooses largest empty block of all. Figure (a) below shows an
example memory configuration after a number of placement and swapping-out
operations. The last block that was used was a 22-Mbyte block from which a 14-
Mbyte partition was created. Best-fit will search the entire list of available blocks and
make use of the 18-Mbyte block, leaving a 2-Mbyte fragment. First-fit results in a 6-
Mbyte fragment, and next-fit results in a 20-Mbyte fragment. Which of these
approaches is best will depend on the exact sequence of process swapping that occurs
and the size of those processes.
The first-fit algorithm is not only the simplest but usually the best and fastest as well.
The next-fit algorithm tends to produce slightly worse results than the first-fit. The
next-fit algorithm will more frequently lead to an allocation from a free block at the
end of memory. The result is that the largest block of free memory, which usually
appears at the end of the memory space, is quickly broken up into small fragments.
Thus, compaction may be required more frequently with
next-fit. On the other hand, the first-fit algorithm may litter the front end with small
free partitions that need to be searched over on each subsequent first-fit pass. The
best-fit algorithm,
despite its name, is usually the worst performer. Because this algorithm looks for the
smallest block that will satisfy the requirement, it guarantees that the fragment left
behind is as small as possible. Although each memory request always wastes the
smallest amount of memory, the result is that main memory is quickly littered by
blocks too small to satisfy memory allocation requests. Thus, memory compaction
must be done more frequently than with the other algorithms.
Given memory partitions of 100K, 500K, 200K, 300K, and 600K (in order), how
would each of the First-fit, Best-fit, and Worst-fit algorithms place processes of 212K,
417K, 112K, and 426K (in order)? Which algorithm makes the most efficient use of
memory?
First-fit:
212K is put in 500K partition
417K is put in 600K partition
112K is put in 288K partition (new partition 288K = 500K - 212K)
426K must wait
Best-fit:
212K is put in 300K partition
417K is put in 500K partition
112K is put in 200K partition
426K is put in 600K partition
Worst-fit:
212K is put in 600K partition
417K is put in 500K partition
112K is put in 388K partition (600K – 212K)
426K must wait
In this example, Best-fit turns out to be the best.
ALGORITHM:
First Fit Algorithm
1. Start
2. Accept no. of partition(n) and size of each partition(S[i]) and no. of processes(P)
and size of each process(SP[i]) from user.
3. Declare i, j, flag[10]
4. for(i=0;i<n;i++)
5. Initialize flag[i]=0
6. End of for loop
7. for(i=0; i<n; i++)
8. for(j=0;j<p;j++)
9. if( (s[i]>=sp[j]) && (flag[j]==0) ) then
flag[j]=1;
printf("\nP%d",j);
printf(" %d\t\t%d",sp[j],s[i]);
break;
10. End of if
11. End of for loop
12. End of for loop
13. End
Best Fit Algorithm:
1. Start
2. Accept no. of partition(n) and size of each partition(S[i]) and no. of processes(P)
and size of each process(SP[i]) from user.
3. Declare i, j, flag[10], temp
4. for(i=0;i<n;i++)
5. for(j=i+1;j<n;j++)
6. if(s[i]>=s[j]) then
temp=s[i]
s[i]=s[j]
s[j]=temp
7. End of if
8. End of for
9. End of for
10. for(i=0;i<n;i++)
11. flag[i]=0
12. for(i=0;i<n;i++)
13. for(j=0;j<p;j++)
14. if( (s[i]>=sp[j]) && (flag[j]==0) ) then
flag[j]=1;
printf("\nP%d",j);
printf(" %d\t\t%d",sp[j],s[i]);
break;
15. End of if
16. End of for
17. end of for
18. end
Worst Fit algorithm
1. Start
2. Accept no. of partition(n) and size of each partition(S[i]) and no. of processes(P)
and size of each process(SP[i]) from user.
3. Declare i, j, flag[10], temp
4. for(i=0;i<n;i++)
5. for(j=i+1;j<n;j++)
6. if(s[i]<=s[j]) then
temp=s[i];
s[i]=s[j];
s[j]=temp
7. End of if
8. End of for
9. End of for
10. End
CONCLUSION:
Implementation of memory allocation algorithms performed successfully and
obtained output.
EXPERIMENT NO: 09
PROBLEM STATEMENT:
To Study and implementation of Data Hazards
THEORY:
In the domain of central processing unit (CPU) design, hazards are problems with
the instruction pipeline in CPU micro architectures when the next instruction cannot
execute in the following clock cycle,[1]
and can potentially lead to incorrect
computation results. There are typically three types of hazards:
data hazards
structural hazards
control hazards (branching hazards)
Data hazards
Data hazards occur when instructions that exhibit data dependence modify data in
different stages of a pipeline. Ignoring potential data hazards can result in race
conditions (sometimes known as race hazards).
The use of the result of the SUB instruction in the next three instructions causes a data
hazard, since the register $2 is not written until after those instructions read it.
There are three situations in which a data hazard can occur:
1. read after write (RAW), a true dependency
2. write after read (WAR), an anti-dependency
3. write after write (WAW), an output dependency
Consider two instructions i1 and i2, with i1 occurring before i2 in program order.
1. Read After Write (RAW)
A read after write (RAW) data hazard refers to a situation where an instruction
refers to a result that has not yet been calculated or retrieved. This can occur
because even though an instruction is executed after a previous instruction, the
previous instruction has not been completely processed through the pipeline.
(i2 tries to read a source before i1 writes to it)
Example
i1. R2 <- R1 + R3
i2. R4 <- R2 + R3
The first instruction is calculating a value to be saved in register R2, and the
second is going to use this value to compute a result for register R4. However,
in a pipeline, when we fetch the operands for the 2nd operation, the results
from the first will not yet have been saved, and hence we have a data
dependency.We say that there is a data dependency with instruction i2, as it is
dependent on the completion of instruction i1.
2. Write After Read (WAR)
A write after read (WAR) data hazard represents a problem with concurrent
execution. (i2 tries to write a destination before it is read by i1).
Example
i1. R4 <- R1 + R5
i2. R5 <- R1 + R2
If we are in a situation that there is a chance that i2 may be completed
before i1 (i.e. with concurrent execution) we must ensure that we do not store
the result of register R5before i1 has had a chance to fetch the operands.
3. Write After Write (WAW)
A write after write (WAW) data hazard may occur in a concurrent
execution environment.
(i2 tries to write an operand before it is written by i1)
Example
i1. R2 <- R4 + R7
i2. R2 <- R1 + R3
We must delay the WB (Write Back) of i2 until the execution of i1.
4. Structural hazards
A structural hazard occurs when a part of the processor's hardware is needed
by two or more instructions at the same time. A canonical example is
a single memory unit that is accessed both in the fetch stage where an
instruction is retrieved from memory, and the memory stage where data is
written and/or read from memory.
.
5. Control hazards (branch hazards)
Branching hazards (also known as control hazards) occur with branches. On
many instruction pipeline micro architectures, the processor will not know the
outcome of the branch when it needs to insert a new instruction into the
pipeline.
CONCLUSION:
We studied and implemented data hazards successfully.
EXPERIMENT No: 10
PROBLEM STATEMENT:
Procedure for execute the Assembly program using TASM
THEORY:
1. Assembly language programs are converted into executable machine code by a
utility program referred to as an assembler, the conversion process being referred to as
assembly or assembling the program.
2. Assembly language (sometimes abbreviated as ASM, usually as the file
extension for a text file which is used as a code for a program written in Assembly
language, or in the names of assemblers, like FASM, MASM, NASM and TASM) is a
lowlevel programming language for computers, microprocessors, microcontrollers,
and other programmable devices in which each statement corresponds to a single
machine language instruction. An assembly language is specific to a certain computer
architecture, in contrast to most highlevel programming languages, which generally
are portable to multiple systems.
What is TASM assembler?
The Turbo Assembler (TASM) is an x86 assembler that uses the Intel syntax for
MSDOS and Microsoft Windows. Beginning with TASM 8.0 there are two versions
of the assembler one for 16 bit and 32bit assembly sources, and another (ML64)
for 64bit sources only.
Assembling and Running Assembly Language Programs
An assembly language program must be assembled and linked before it can be
executed. The assembler produces an object file (extension .OBJ). This file is taken
by the linker and an executable program (extension .EXE) is produced, assuming
there were no errors in the program. We use the MASM assembler and the LINK
linker. These are available on NAL under Programming:“TASM filesv 5.0”.
When saving the file with Notepad, you MUST save it with the “File Type” set to
“All Files”. You should now select the MSDOS Prompt (Command PROMPT) from
the Start button menu (sometimes under Programs option)
Following are steps to execute a assembly program in tasm assembler.
1. Save .asm extention file by writing code in text editor.
2. Open dos prompt
3. Go the target file by prompt
4. Write tasm filename.asm and press enter
5. Write tlink filename.obj and press enter
6. Write debug filename.exe and press enter
7. Cursor will be displayed. Press –t for single step debugging mode otherwise –g for
direct compilation.
Tasm folder must contains
1. Tasm exe
2. Tlink exe
3. Td.exe
Following are steps to execute a mixed language program in TURBOC.
1. Write a program in turbo c editor and save it as .cpp file
2. Go the compile
3. Run the compile file
Note: GUI based Emulator 8085/ 8086 can also be used to write and execute assembly
programs. In the event of errors, you must edit your program and correct the errors.
Then you repeat the above steps to assemble and link your program, before running it.
Similarly, if you modify your program, you must assemble and link it before running
it again.
CONCLUSION:
We studied the working of TASM software. We also executed some basic programs
on TASM successfully.