代写data编程、代做Java/Python程序语言

日期：2024-03-03 08:35

Project1

Overview

In Project 1, our objective is to familiarize you with some fundamental

concepts within RISC-V and enable you to write basic programs using

RISC-V assembly language. In this assignment, your first task is to

implement a simple ALU (Arithmetic Logic Unit) that produces correct

outputs based on the provided test inputs. Following that, you are

required to utilize RISC-V to implement several straightforward programs,

such as generating odd values within a specified range and printing

simple drawings based on a bitmap.

Before you start working on this project, you need to:

Requirements

1. ALU

In general, the ALU here is a rather simple Arithmetic Logic Unit. There is

no need for instruction parsing; instead, you are only required to

implement various ALU functions corresponding to different instructions,

such as add, sub and so on. The inputs for the ALU functions come in

single forms: r1, r2, rd which specify the locations of registers of inputs

and output.

1.1 ALU Functions

You are required to support the following RISC-V instruction in your ALU.

1.2 Function Format

Review the content of RISC-V

add, sub,

and, nor, or, xor

beq, bne, slt

sll, srl, sra

The initial address of the registers, denoted as t0. As the inputs in the

"and" function are indices of a pre-existing registers, some basic address

operations are necessary.

We define t1 to represent the value of the first input, t2 for the second

input, and t4 to represent the value of t1 and t2 after undergoing certain

operations within the ALU. It means that you should do this in your

program and we will check it randomly. If you don't follow the pattern,

you will miss 50% points related to the alu task.

2.Branch

In this program, your task is to determine the odd numbers within a given

range based on the input. The process involves several "for" and "if"

operations, aiming to familiarize you with the branch operations in RISCV through the implementation of this program.

Function pseudocode

add:

lui a5,%hi(registers)

addi t0,a5,%lo(registers)

slli a0,a0,2

slli a1,a1,2

slli a2,a2,2

add t1, t0, a0

add t2, t0, a1

add t3, t0, a2

lw t1,0(t1)

lw t2,0(t2)

add t4, t1, t2

sw t4,0(t3)

riscv64-unknown-elf-gcc -march=rv32im -mabi=ilp32 -O3 alu.s -o

alu

./alu

In this program, you should use t0 to represent the index, t1 for i, t2 for j,

and t3 for k. Similar to the ALU program, failing to adhere to these

specifications may result in a 50% point deduction.

Hint

__floatsidf : Call the function __floatsidf . This function involves

converting an integer to a double-precision floating-point number.

sqrt : Call the sqrt function, which computes the square root of a

floating-point number.

__fixdfsi : Call the function __fixdfsi . This function likely involves

converting a double-precision floating-point number to an integer.

The statements can get the square root of i.

This instruction would calculate the remainder when the value in register

a is divided by the value in register b , and store the result in the

primes = array of integers

procedure generatePrimes(n)

index = 0

for i from 2 to n

k = integer square root of i

for j from 2 to k

if i is divisible by j

break

if j>k is true

primes[index] = i

index = index + 1

addi a0,t1,0

call __floatsidf

call sqrt

call __fixdfsi

rem a, b, result

specified destination register ( result in this case).

3.Array

In this program, you are required to read a two-dimensional array storing

a bitmap and print out the bits, thereby generating a meaningful output.

riscv64-unknown-elf-gcc -march=rv32im -mabi=ilp32 -O3 branch.s -o

branch -lm

./branch

unsigned char bitmap[][8] = {

{0x10, 0x00, 0x10, 0x00, 0x10, 0x40, 0x00, 0x20},

{0x08, 0x04, 0x10, 0x00, 0x10, 0x40, 0x00, 0xf0},

{0x7f, 0x78, 0x1f, 0xfc, 0x10, 0x40, 0x1f, 0x00},

{0x00, 0x40, 0x20, 0x80, 0x13, 0xf8, 0x10, 0x00},

{0x22, 0x40, 0x20, 0x80, 0x18, 0x48, 0x11, 0x00},

{0x14, 0x40, 0x40, 0x80, 0x54, 0x48, 0x21, 0x00},

{0xff, 0x7e, 0x1f, 0xf8, 0x50, 0x48, 0x21, 0x00},

{0x08, 0x48, 0x10, 0x80, 0x50, 0x48, 0x3f, 0xfc},

{0x08, 0x48, 0x10, 0x80, 0x97, 0xfe, 0x01, 0x00},

{0x7f, 0x48, 0x10, 0x80, 0x10, 0x40, 0x09, 0x20},

{0x08, 0x48, 0xff, 0xfe, 0x10, 0xa0, 0x09, 0x10},

{0x2a, 0x48, 0x00, 0x80, 0x10, 0xa0, 0x11, 0x08},

{0x49, 0x48, 0x00, 0x80, 0x11, 0x10, 0x21, 0x04},

{0x88, 0x88, 0x00, 0x80, 0x11, 0x10, 0x41, 0x04},

{0x28, 0x88, 0x00, 0x80, 0x12, 0x08, 0x05, 0x00},

{0x11, 0x08, 0x00, 0x80, 0x14, 0x06, 0x02, 0x00}

};

procedure printBitmap(size):

for i from 0 to size - 1:

for j from 0 to 7:

for k from 7 to 0 step -1:

......

In this program, you only need implement printBitmap. Besides, you

should use t0 to represent the size, t1 for i, t2 for j, and t3 for k. Failing to

adhere to these specifications may result in a 50% point deduction.

Result should be similar to

Hint

In this problem, you may need to print three kinds of character.

By checking the ascii code of characters, you will understand it.

Report

The report of this project should be no longer than 5 pages. Keep your

words concise and clear.

In your report, you should include:

li a0 10

call putchar #print '\n'

li a0 32

call putchar #print ' '

li a0 49

call putchar #print '1'

riscv64-unknown-elf-gcc -march=rv32im -mabi=ilp32 -O3 array.s -o

array

./array

Submission and Grading

1. Submission

You should put all of your source files (alu.s, branch.s, array.s, report.pdf)

in a folder and compress it in a zip. Name it with your student ID. Submit

it through BB. The deadline for this report is 2024/03/10. If you fail to

submit your assignment by the deadline, 10 points will be deducted from

your original mark for each day you are late, up to a maximum of 30

points. Assignments submitted more than 3 days after the deadline will

not be considered valid and will be marked as 0 points.

2. Grading Details

Implement the task about ALU - 40 %

Implement the task about odd number - 25%

Implement the task about bitmap - 25%

Report - 10%

In grading, we have more tests about tasks. Please make sure the

completeness of codes.

3. Honesty

We take your honesty seriously. If you are caught copying others' code,

you will get an automatic 0 in this project. Please write your own code.

1. Your big picture thoughts and ideas, showing us you really

understand RISC-V assembly.

2. The high level implementation ideas. i.e. how you break down the

problem into small problems, etc.

3. The implementation details. i.e. explain some special tricks used.

4. the screenshots of result