CSE 30语言编程代写、代做C/C++程序

项目预算：开发周期：发布时间：要求地区：

Assignment 6: Floating Point
CSE 30: Computer Organization and Systems, Fall 2023
Due: Tuesday Nov 14, 2023
Please read over the entire assignment before starting to get a sense of what you will need to
get done in the next week. REMEMBER: Everyone procrastinates but it is important to know
that you are procrastinating and still leave yourself enough time to finish. Start early, start often.
You MUST run the assignment on the pi-cluster. You HAVE to SSH: You will not be able to
compile or run the assignment otherwise.
ACADEMIC INTEGRITY REMINDER: you should do this assignment on your own.
If you work with others, be sure to cite them in your submission. Never copy from
others.
Please read the FAQ and search the existing questions on Edstem before asking for help.
This reduces the load on the teaching staff, and clutter/duplicate questions on Edstem.
Version updates:
● 1.0 [Nov 8] Final Draft
● 1.1 [Nov 8] Fix midpoint due date Sunday -> Friday
● 1.2 [Nov 9] Fix: somehexnums.txt 0x8000 to 0x4000 since it is 15 bit representation.
● 1.3 [Nov 9] Clarify: style won’t be regraded during resubmission
● 1.4 [Nov 10] Prerelease: Midpoint answers are visible before due date.
● 1.5 [Nov 12] Fix git clone link, fix # of bits in mantissas in page 4 table to be 8 bits
Table of Contents
1. Learning Goals
2. Assignment Overview
3. Getting Started
4. How the Program Works
5. Program Implementation
a. Functions to Implement
b. Developing Your Code
c. Testing Your Code
6. Submission and Grading
a. Submitting
b. Grading Breakdown [50 pts]
Learning Goals
● Programming in ARM assembly
○ Bit masking
○ Function call
○ Branching
● Working with floating point numbers
● Coordinating a program with both ARM assembly and C code (you aren’t writing in C)
Assignment Overview
At the peak of time where pirates and bounty hunters are in the air. Porco Rosso makes his
rounds in the vast ocean to capture any air pirates that disturb the peace near Adriano hotel.
On the radio, Porco Rosso tunes in to listen to his next job, however he discovers an issue. The
coordinates given out are in 15-bit floating-point format. He doesn’t know how to convert from
this format and only knows the standardized IEEE 754 format. Gina only has devices that are
written in ARM so Porco plans to rely on your assembly skills to create the conversion function.
Help him write and test code to convert the coordinates into IEEE format!
A note about representing number literals
In the number 8’b1101_0011:
● 8 is the number of binary bits in this number, in base-10.
● b means binary. Other formats are d for decimal, o for octal, and h for hexadecimal.
● To conserve space, we may also write the bits in hexadecimal, 0xd3 is equivalent to
8’b1101_0011.
● _ is a spacer character that is only there to make it easier to read. It has no numerical
meaning. A '_' is usually placed every four digits.
You can read more about where this number literal representation comes from here. (Note:
Anything past the first slide is irrelevant to this course, but will be useful in CSE 140 & 141.)
The 15-bit FP Format
The 15-bit floating-point format is similar to, but not the same as, the one we studied in class. It
has a sign bit, 6 bits of biased exponent, a bias value of 31 (base-10), and 8 bits of mantissa.
Note that we include special cases to represent infinities and subnormal numbers.
The following figure illustrates the bit assignments:
FP Format (15-bit)
sign
(1 bit)
exponent
(6 bits, bias = 31)
mantissa
(8 bits)
Points to note:
1. There is an implied “1.” in front of the mantissa, unless it is a subnormal number.
2. Subnormal numbers have an exponent field of 6’b000000 which represents 2 and
−30
implies a “0.” in front of the mantissa.
3. “Infinite” numbers have an exponent field equal to 6’b111111 with ANY value in the
mantissa.
The following table shows how to interpret the exponent fields and mantissa fields.
Exponent/mantissa represents Notes
111111/mmmmmmm infinity infinity
111110/mmmmmmm 2^31 x 1.mmmmmmm normal number
111100/mmmmmmm 2^29 x 1.mmmmmmm normal number
111000/mmmmmmm 2^25 x 1.mmmmmmm normal number
100000/mmmmmmm 2^1 x 1.mmmmmmm normal number
011111/mmmmmmm 2^0 x 1.mmmmmmm normal number
001111/mmmmmmm 2^-16 x 1.mmmmmmm normal number
000011/mmmmmmm 2^-28 x 1.mmmmmmm normal number
000001/mmmmmmm 2^-30 x 1.mmmmmmm normal number
000000/mmmmmmm 2^-30 x 0.mmmmmmm subnormal number
(no leading 1)
```````````````````````````````````````````````````````````````````````````````````````````````````````````
Exponent bits are shown in purple below to help you distinguish it from the sign bit and
mantissa.
Number Encoding in 15-bits
+0.0 15’b000_0000_0000_0000 (15 bits of 0 in binary)
-0.0 15’b100_0000_0000_0000
Number `15-Bit
Representation
Binary
Representation
Base-10
Representation
+∞
15’b011_1111_xxxx_xxxx +Inf
-∞
15’b111_1111_xxxx_xxxx -Inf
Most positive # 15’b011_1110_1111_1111 2^31 *
9’b1.11111111
4286578688
Smallest positive
#
(subnormal)
15’b000_0000_0000_0001 2^-30 *
9’b0.00000001
2^-38 ≅
3.637978807e-12
Most negative # 15’b111_1110_1111_1111 -2^31 *
9’b1.11111111
-4286578688
Smallest
negative #
(subnormal)
15’b100_0000_0000_0001 -2^-30 *
9’b0.00000001
-2^-38 ≅
-3.637978807e-1
2
IEEE-754 Single Precision Format
IEEE-754 Single Precision Format
sign
(1 bit)
exponent
(8 bits, bias = 127)
mantissa
(23 bits)
Subnorms
The bias for the IEEE Format is 127 (base-10) and the format uses an implied “1.” for normal
numbers, as usual. The smallest possible exponent is -126 represented by 8’b0000_0001 for
normal numbers, whereas 8’b0000_0000 represents subnormal numbers. For subnormal
numbers, we prepend the mantissa with “0.” instead of “1.” similar to how subnormal numbers
are evaluated in our 15-bit FP format.
Infinities
In IEEE single precision, any exponent of all 1’s (8’b1111_1111) represents a number too
large to represent. For example, 0xff80_0000 is a number with a negative sign bit, all 1’s for
the exponent and all 0’s for the mantissa. This represents negative infinity (-Inf). Similarly,
0x7f80_0000 represents positive infinity (+Inf). Note that the mantissa bits are all 0. Non-0
mantissa bits represent another kind of IEEE special number (NaN, “not a number”) which is not
required in this assignment since our 15-bit floating point format does not use NaN.
Summary of Select Conversions
FP 15-bit FP IEEE-754 Single
+0 15’b000_0000_0000_0000 0x00000000
-0 15’b100_0000_0000_0000 0x80000000
2^-38 15’b000_0000_0000_0001 0x2c800000
-2^-38 15’b100_0000_0000_0001 0xac800000
4286578688 15’b011_1110_1111_1111 0x4f7f8000
-4286578688 15’b111_1110_1111_1111 0xcf7f8000
+Inf 15’b011_1111_xxxx_xxxx 0x7f800000
-Inf 15’b111_1111_xxxx_xxxx 0xff800000
Getting Started
Developing Your Program
For this class, you MUST compile and run your programs on the pi-cluster.
Need help or instructions? See the Edstem FAQ. (Do NOT wait until the end to try this. There
will be limited or no ETS support on the weekends!)
We’ve provided you with the starter code at the following link:
https://github.com/cse30-fa23/hw6-starter
1. Download the files in the repository.
a. You can either use
git clone https://github.com/cse30-fa23/hw6-starter.git
directly from pi-cluster, or download the repo locally and scp the folder to
pi-cluster if that doesn’t work.
2. Fill out the fields in the README before turning in.
Running Your Program
We’ve provided you with a Makefile so compiling your program should be easy!
Additionally, the reference solution binary will be placed on Saturday 11/11 morning at:
/home/linux/ieng6/cs30fa23/public/bin/fpconvert-a6-ref
Makefile: The Makefile provided will create a fpconvert executable from the source files
provided. Compile it by typing make into the terminal. Run make clean to remove files
generated by make.
How the Program Works
Your program will take a filename as an argument and read it in. This file is a txt file storing the
15 bit FP numbers. The main function (implemented for you in main.c) will parse the input file
and call the fpconvert function which you will implement in assembly on each 15-bit FP
number to convert it into IEEE floating point format, and print the result to stdout.
Once you compiled the program with make, you can run it as follows:
./fpconvert somehexnums.txt
where somehexnums.txt is the name of the input txt file that holds the hex numbers you
want to convert.
Input Guarantees
● fpconvert will be only given valid 15-bit wide numbers.
Program Implementation
Files to Edit
You need to edit fpconvert.S and convert_inf.S
Functions to Implement
You will need to implement 1 function within fpconvert.S:
● fpconvert(n): This is the function that will do most of the floating-point conversion.
○ Argument: n the 15-bit FP number to convert
○ Returns: n’s equivalent IEEE 754 single precision representation.
○ If n is ±infinity, you MUST call convert_infinity(n) to do the conversion
instead.
You need to implement 1 function within convert_inf.S
● convert_infinity(n):
○ Argument: n the 15-bit FP number to convert (should only be ±infinity)
○ Returns: the FP number’s equivalent IEEE 754 single precision representation.
NOTE:
● 32-bit ARM stores arguments passed into the function in registers r0-r3; n only
symbolizes that the function takes in one argument. You cannot directly use n in your
assembly program to refer to the first argument.
● As registers are all 32-bits wide, our 15-bit floating point format will always only occupy
the least significant 15 bits, the upper 17 bits will be padded with 0’s.
● Return value should be stored in r0.
Calling a Function in ARM
To call a function in ARM, you must use the bl “branch and link” instruction. It is not sufficient
or correct to use a regular branch instruction. Without branch-and-link, the return operations in
the epilogue of the function will not work and return as expected.
Developing Your Code
Development Process
To make development easier, you should first implement the conversion of normal numbers.
Test your code on a range of normal numbers (smallest, largest). For the smallest numbers, you
should familiarize yourself with their scientific notation representations. You can also check the
IEEE column of the output to see if it matches the expected IEEE version. Additionally, be sure
to check the special cases of +0.0, -0.0, +Inf, and -Inf.
After thoroughly testing the functionality of your code, you should consider subnormal numbers.
Subnormal numbers are represented when the exponent field is 6’b000000.
After implementing the conversion of subnormal numbers, your code should be able to produce
all of the values in the Summary of Select Conversions table.
Development Tips
Before you write assembly code, think about the algorithm.
● How are the 15-bit format and the 32-bit IEEE format similar and different?
● How do I break down the 15-bit format into the 3 individual fields?
● How does each field convert from the 15-bit format to the 32-bit IEEE format?
You should find the bitwise instructions useful for this assignment. In particular, you will want to
make use of bitmasks.
While an immediate can only be 8 bits wide, you can use left and right shifts to move the mask
into the right position. For example, if you need the bitmask 0xFF00, you can shift the
immediate 0xFF left by 8 bits.
Testing your Code
To run your code you need a txt file that holds the hex numbers that you want to convert,
separated by a new line.
Example text input file, named somehexnums.txt:
0x0000
0x4000
0x3f00
0x7f00
0x3eff
0x0001
0x7eff
0x4001
NOTE: you should make sure each hexadecimal number only has four digits, otherwise you
may get unexpected results.
Checking For Exact Output Match
A common technique is to redirect the outputs to files and compare against the reference
solution
1
:
./your-program args > output; our-reference args > ref
diff -s output ref
This command will output lines that differ with a < or > in front to tell which file the line came
from.
Debugging Tips
The public autograder will only printf test some features. DO NOT RELY ON THE
AUTOGRADER. (Many CSE 30 students have been burned by this.) Test your code using your
own test cases!
GDB treats ARM assembly labels as functions except those that begin with the prefix “.L”. If
you want to use GDB to debug your ARM code, you will need to prefix your labels with “.L”.
1 You might want to check out vimdiff on the pi-cluster (https://www.tutorialspoint.com/vim/vim_diff.htm).
Thus, ARM code for the given C if statement would look like the code snippet on the right, rather
than the snippet on the left.
if (r5 == 99) {
r3 = r3 + 2;
} else {
r3 = r3 + 3;
}
r4 = r4 - 1;
GDB will not recognize labels: GDB will recognize labels:
cmp r5, 99
bne else
add r3, r3, 2
B end_if
else:
add r3, r3, 3
end_if:
sub r4, r4, 1
cmp r5, 99
bne .Lelse
add r3, r3, 2
b .Lend_if
.Lelse:
add r3, r3, 3
.Lend_if:
sub r4, r4, 1
Allowed ARM Instructions
You are only allowed to use the instructions provided in the ARM ISA Green Card. Failure to
comply will result in a score of 0 on the assignment.
Style Requirements
Reading raw assembly is hard and debugging will be nigh impossible if you don’t put comments!
To encourage you to make your life easier, style will be worth 2 points in this assignment on a
holistic readable/unreadable basis. You will get full style points as long as your code is
reasonably commented to be readable (so that someone who doesn’t know ARM can still
roughly understand what it’s doing), so don’t worry if you can’t get all the details right. However,
you will get no style points if it’s not (e.g. very inconsistent indentation, sparse or unreadable
comments). In addition, staff won't be able to provide any assistance other than styling
advice unless code is readable. For reference, here is the Style Guideline for ARM assembly.
We strongly recommend you to use comments after each instruction to help describe what
step occurs like what is done in the style guide. Note: style will not be graded for
resubmission.
Midpoint (5 Points)
This part of the assignment is due earlier than the full assignment, on
Friday 11/10 at 11:59 pm PST. There are no late submissions on the
Midpoint.
Complete the Gradescope assignment “HW6: Checkpoint”, an Online Assignment that is done
entirely through Gradescope. This assignment consists of a few quiz questions and a
free-response question where you will document your algorithm in plain English or C code.
Discuss your implementations of the following functions: fpconvert and
convert_infinity. Your fpconvert should call convert_infinity when appropriate.
Submission and Grading
Submitting
1. Submit your files to Gradescope under the assignment titled “HW6 (Coding): Floating
Point”. You will submit ONLY the following files:
fpconvert.S
convert_inf.S
README.md
Submission will open by Saturday morning. You should test your code extensively on
pi-cluster before submitting to gradescope.
You can upload multiple files to Gradescope by holding CTRL (⌘ on a Mac) while you
are clicking the files. You can also hold SHIFT to select all files between a start point
and an endpoint.
Alternatively, you can place all files in a folder and upload the folder to the assignment.
Gradescope will upload all files in the folder. You can also zip all of the files and upload
the .zip to the assignment. Ensure that the files you submit are not in a nested folder.
2. After submitting, the autograder will run a few tests:
a. Check that all required files were submitted.
b. Check that fpconvert.S and convert_inf.S compiles.
c. Runs some sanity tests on the resulting fpconvert executable.
Grading Breakdown [5 + 45 points]
Make sure to check the autograder output after submitting! We will be running
additional tests after the deadline passes to determine your final grade. Also, throughout this
course, make sure to write your own test cases. It is bad practice to rely on the minimal
public autograder tests as this is an insufficient test of your program.
To encourage you to write your own tests, we are not providing any public tests that have
not already been detailed in this writeup.
The assignment will be graded out of 50 points and will be allocated as follows:
● Midpoint writeup: 5 points. This part of the assignment is due earlier than the full
assignment, on Friday 11/10. Complete the Gradescope assignment “Homework 6:
Checkpoint”.
● Code compiles with no warnings: 1 point
● Style: 2 points
● Public tests with the provided examples.
● Private tests with hidden test cases.
NOTE: The tests expect an EXACT output match with the reference binary. There will be
NO partial credit for any differences in the output. Test your code - do NOT rely on the
autograder for program validation.
Make sure your assignment compiles correctly through the provided Makefile on the
pi-cluster without warnings. Any assignment that does not compile will receive 0 credit.
[Optional] Bells and Whistles
2
(epsilon points)
Write a new function add_fp(a, b) that takes in 2 numbers a and b that are in the 15-bit
floating point format. It should add these 2 numbers together and return the value. However,
what makes this complicated is that a and b may not have the same exponent! You’ll need to
make the exponents the same first before you can add them.
This part of the assignment will NOT be graded - and does not need to be submitted. It is
completely up to you to try writing a program which achieves the above output.
The Bells and Whistles component may be submitted to a separate Gradescope assignment:
Homework 6 Optional: Bells and Whistles.
2
In our experience, students like extra credit. However, we find that extra credit isn't used by students
who need it the most. Thus, we have an extra credit where the number of points assigned is epsilon,
where epsilon is a very small number [0, 1).