Description
hello, I need help in this project step by step with explanations please, I need clear, right answer please this project is so important project to me. how to use and modify a popular architectural simulator, SimpleScalar, to analyze the performance impact of different architectural designs. I need just part one
Unformatted Attachment Preview
ECE/CS 466 Project
In this project, you are asked to learn how to use and modify a popular architectural simulator,
SimpleScalar, to analyze the performance impact of different architectural designs. The project
has two parts. The second part is only required for graduate students.
First, you need to download “simplesim-3v0e.tgz” from the Blackboard and install the simulator
on your computer. If you have access to any UIC servers that support C programming, you can
also install the simulator there. Note: If you are going to install the simulator on your computer
and your computer is Unix-like (e.g., MacOS or Linux), you can directly install the simulator; but
if your computer is windows-based, you need to install the simulator either under “cygwin” or a
Linux-like virtual machine.
When you install the codes, please use the PISA configuration (follow the installation instruction
in file “README” and use “make config-pisa”). To verify the installation, run the testing with
command of “./sim-safe tests/bin.little/test-math”. You should see printed results as shown in the
class.
Next, you will use SimpleScalar to run a SPEC2006 benchmark program, 410.bzip2. This is an
integer application for compression. You can download the PISA binary code of bzip2 and the
input file (input.combined) from the blackboard. It’s better to put the two files under the same
directory with sim-outorder and sim-safe on your computer.
Now, you can begin the following experiments to see the performance impact of varying hardware
parameters and implementations. Run the simulation, and report and analyze the observed results.
Please attach the screenshots of related statistics and starting time of each simulation
experiment in your report.
Note: You don’t need to include all the statistics; only the performance related ones would be
enough. This is NOT a group project. You should run all the simulations by yourself.
Part 1
Since running the program from beginning to end using the most detailed simulator included, simoutorder, would take too long for most applications. sim-outorder supports an option to set the
maximum number of instructions to be simulated using “-max:inst”.
1. What is the performance of running the program, bzip2, under the default system setup
(without changing any simulation parameters) using following command and how long
does it take to run the simulation for 500 million instructions?
./sim-outorder -max:inst 500000000 bzip2 input.combined
2. The above experiment only performs detailed simulation on 500 million instructions.
Based on the simulation running time in Question 1, estimate how long it would take
to simulate the program’s execution in details from beginning to end using the default
configuration. Note: Do not actually run the detailed simulation from beginning to end.
It may take hours or even days to finish depending on the speed of your computer.
3. Usually, the application behavior during the initialization phase is different from that
during the steady state. A widely used approach is to fast-forward the program to
bypass the initialization phase and then run detailed simulation. Now use the following
command to fast-forward the first 1000 million instructions and then collect detailed
statistics on the next 500 million instructions. How much is the performance difference
compared with Question 1 without forwarding?
./sim-outorder -fastfwd 1000000000 -max:inst 500000000 bzip2 input.combined
4. For the following questions (Q4 and Q5), fast-forward the first 1000 million
instructions and then collect detailed statistics on the next 500 million instructions.
How much is the performance loss if the processor uses in-order execution instead of
the default out-of-order execution to run the program?
5. An advantage of using a simulator is that you can vary the processor parameters to see
their performance impact and find the optimal configuration. In the default
configuration, the processor pipeline (fetch, decode, issue, and commit) bandwidth is
4. If all the other parameters are kept the same, how much is the performance
improvement when the pipeline bandwidth increases from 1 to 2, 4, 8, and 16? If the
cost of building a single-issue processor (with pipeline bandwidth of one) is X, and
every time when the pipeline bandwidth doubles, the cost increases by 15%, which
design is the most cost-effective one for this program?
Hint:
•
•
•
•
•
•
•
•
•
SimpleScalar is written in C. So, you need to have a C compiler on your computer to
install SimpleScalar (GCC is a free one that can be downloaded online). Please follow
the instruction in file “README” to install SimpleScalar on your computer. Please do
not install the SimpleScalar compiler part. It is complicated and is not needed for our
project.
When you install SimpleScalar, you may get some errors reported by the compiler. This
is because SimpleScalar was developed on old platforms, and some definitions have
been changed since then. You can comment the lines in header files that cause the errors.
After you fix the currently reported errors and rerun “make”, the compiler may report
more errors. It may take several rounds to fix all the errors. Once all the errors are fixed,
you may run “make clean” and then “make” to generate the final binary code.
Before each simulation run, you need to delete the output file “input.combined.bz2”
(e.g. using the command “rm input.combined.bz2”) generated in the previous
simulation run. Otherwise, the simulation will stop immediately.
You need to use “sim-outorder” in order to get any performance-related statistics such
as the CPI or IPC value.
There is no simulator called sim-inorder for in-order execution. But sim-outorder has
an option to perform in-order execution.
The reported “sim_elapsed_time” is how fast the simulator runs on your computer
instead of how fast the program runs on the simulated processor.
If you do not get the result for Question 1 within 15 minutes, it’s very likely that the
option “-max:inst” is put in a wrong place and does not take effect. You should kill the
program and restart the correct simulation.
For Question 2, you can use “sim-safe” to run the program till the end to get the total
number of instructions of the program (it may take a few hours depending on the speed
of your computer) and then do the estimation.
For Question 5, you should change the fetch queue size, decode width, issue width and
commit width at the same time to limit the number of experimental combinations.
Purchase answer to see full
attachment
