np/simbench
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change benchmark to calc MD5 on 1024 softcores

Browse Source
This commit is contained in:
Nikolay Puzanov
2023-06-15 17:40:46 +03:00
parent 89c82cb611
commit 047bd9c42b
21 changed files with 1376 additions and 931 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
source/firmware/.gitignore vendored
View File

@@ -2,3 +2,4 @@
*.bin
*.map
*.asm
compile_flags.txt

13
source/firmware/Makefile
View File

@@ -1,21 +1,12 @@
PROJECT := fw
SOURCES := crt0.s main.c uprintf.c
SOURCES := crt0.s main.c uprintf.c md5.c
CPU_RAM_REG := ram_reg
ARCH := riscv32-none-elf
CFLAGS := -O2 -Wall -march=rv32i -mabi=ilp32 -mstrict-align \
-nostartfiles \
-ffunction-sections -lgcc \
-nostartfiles -ffunction-sections -lgcc \
-Wl,-Tpicorv32-minimal.ld,-static,-Map,$(PROJECT).map
# CFLAGS := -O3 -Wall -march=rv32i -mabi=ilp32 -mstrict-align \
# -nostartfiles \
# -ffunction-sections \
# -ffreestanding -lgcc \
# -Wl,-T,picorv32-minimal.ld,-static,-Map,$(PROJECT).map
# -nostdlib
ELF = $(PROJECT).elf
BIN = $(PROJECT).bin
ASM = $(PROJECT).asm

1180
source/firmware/fw.mem
View File

File diff suppressed because it is too large Load Diff

77
source/firmware/main.c
View File

@@ -1,82 +1,27 @@
#include "../io_reg.h"
#include "md5.h"
#include "uprintf.h"
#include <stdint.h>
#define DATA_ADDR 0x10000
#define DATA_LEN 0x10000
void put_char(char c)
{
IO_REG_CONSOLE = c | IO_REG_CONSOLE_SEND;
}
#define N 200
#define CHUNK 4
#define ARR_LEN (10 * N / 3 + 1)
static int arr[ARR_LEN];
void print_digit(int d)
int main(void)
{
static int cnt = 0;
uint8_t result[16];
p("%d", d);
cnt++;
md5Buf((uint8_t *)DATA_ADDR, DATA_LEN, result);
if (cnt == CHUNK) {
p("\n");
cnt = 0;
}
}
/* See: https://en.wikipedia.org/wiki/Spigot_algorithm */
int main()
{
p("\nComputation of %d first digits of PI\n", N);
for (int i = 0; i < ARR_LEN; i++)
arr[i] = 2;
int nines = 0;
int predigit = 0;
for (int j = 1; j < N + 1; j++) {
int q = 0;
for (int i = ARR_LEN; i > 0; i--) {
int x = 10 * arr[i - 1] + q * i;
arr[i - 1] = x % (2 * i - 1);
q = x / (2 * i - 1);
}
arr[0] = q % 10;
q = q / 10;
if (9 == q)
nines++;
else if (10 == q) {
print_digit(predigit + 1);
for (int k = 0; k < nines; k++)
print_digit(0);
predigit = 0;
nines = 0;
}
else {
print_digit(predigit);
predigit = q;
if (0 != nines) {
for (int k = 0; k < nines; k++)
print_digit(9);
nines = 0;
}
}
}
p("%d", predigit);
p("\nDONE\n");
IO_REG_MD5_OUT0 = *(uint32_t *)(result + 0);
IO_REG_MD5_OUT1 = *(uint32_t *)(result + 4);
IO_REG_MD5_OUT2 = *(uint32_t *)(result + 8);
IO_REG_MD5_OUT3 = *(uint32_t *)(result + 12);
/* Stop simulation */
IO_REG_CTRL = IO_REG_CTRL_STOP;

210
source/firmware/md5.c Normal file
View File

@@ -0,0 +1,210 @@
/*
* Derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm
* and modified slightly to be functionally identical but condensed into control
* structures.
*/
#include "md5.h"
#include <stdint.h>
/*
* Constants defined by the MD5 algorithm
*/
#define A 0x67452301
#define B 0xefcdab89
#define C 0x98badcfe
#define D 0x10325476
static uint32_t S[] = {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7,
12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9,
14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16,
23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15, 21,
6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21};
static uint32_t K[] = {
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a,
0xa8304613, 0xfd469501, 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, 0xf61e2562, 0xc040b340,
0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8,
0x676f02d9, 0x8d2a4c8a, 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, 0x289b7ec6, 0xeaa127fa,
0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92,
0xffeff47d, 0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391};
/*
* Padding used to make the size (in bits) of the input congruent to 448 mod 512
*/
static uint8_t PADDING[] = {
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
/*
* Bit-manipulation functions defined by the MD5 algorithm
*/
#define F(X, Y, Z) ((X & Y) | (~X & Z))
#define G(X, Y, Z) ((X & Z) | (Y & ~Z))
#define H(X, Y, Z) (X ^ Y ^ Z)
#define I(X, Y, Z) (Y ^ (X | ~Z))
/*
* Rotates a 32-bit word left by n bits
*/
uint32_t rotateLeft(uint32_t x, uint32_t n)
{
return (x << n) | (x >> (32 - n));
}
/*
* Initialize a context
*/
void md5Init(MD5Context *ctx)
{
ctx->size = (uint64_t)0;
ctx->buffer[0] = (uint32_t)A;
ctx->buffer[1] = (uint32_t)B;
ctx->buffer[2] = (uint32_t)C;
ctx->buffer[3] = (uint32_t)D;
}
/*
* Add some amount of input to the context
*
* If the input fills out a block of 512 bits, apply the algorithm (md5Step)
* and save the result in the buffer. Also updates the overall size.
*/
void md5Update(MD5Context *ctx, uint8_t *input_buffer, size_t input_len)
{
uint32_t input[16];
unsigned int offset = ctx->size % 64;
ctx->size += (uint64_t)input_len;
// Copy each byte in input_buffer into the next space in our context input
for (unsigned int i = 0; i < input_len; ++i) {
ctx->input[offset++] = (uint8_t) * (input_buffer + i);
// If we've filled our context input, copy it into our local array input
// then reset the offset to 0 and fill in a new buffer.
// Every time we fill out a chunk, we run it through the algorithm
// to enable some back and forth between cpu and i/o
if (offset % 64 == 0) {
for (unsigned int j = 0; j < 16; ++j) {
// Convert to little-endian
// The local variable `input` our 512-bit chunk separated into
// 32-bit words we can use in calculations
input[j] = (uint32_t)(ctx->input[(j * 4) + 3]) << 24 |
(uint32_t)(ctx->input[(j * 4) + 2]) << 16 |
(uint32_t)(ctx->input[(j * 4) + 1]) << 8 |
(uint32_t)(ctx->input[(j * 4)]);
}
md5Step(ctx->buffer, input);
offset = 0;
}
}
}
/*
* Pad the current input to get to 448 bytes, append the size in bits to the
* very end, and save the result of the final iteration into digest.
*/
void md5Finalize(MD5Context *ctx)
{
uint32_t input[16];
unsigned int offset = ctx->size % 64;
unsigned int padding_length =
offset < 56 ? 56 - offset : (56 + 64) - offset;
// Fill in the padding and undo the changes to size that resulted from the
// update
md5Update(ctx, PADDING, padding_length);
ctx->size -= (uint64_t)padding_length;
// Do a final update (internal to this function)
// Last two 32-bit words are the two halves of the size (converted from
// bytes to bits)
for (unsigned int j = 0; j < 14; ++j) {
input[j] = (uint32_t)(ctx->input[(j * 4) + 3]) << 24 |
(uint32_t)(ctx->input[(j * 4) + 2]) << 16 |
(uint32_t)(ctx->input[(j * 4) + 1]) << 8 |
(uint32_t)(ctx->input[(j * 4)]);
}
input[14] = (uint32_t)(ctx->size * 8);
input[15] = (uint32_t)((ctx->size * 8) >> 32);
md5Step(ctx->buffer, input);
// Move the result into digest (convert from little-endian)
for (unsigned int i = 0; i < 4; ++i) {
ctx->digest[(i * 4) + 0] = (uint8_t)((ctx->buffer[i] & 0x000000FF));
ctx->digest[(i * 4) + 1] =
(uint8_t)((ctx->buffer[i] & 0x0000FF00) >> 8);
ctx->digest[(i * 4) + 2] =
(uint8_t)((ctx->buffer[i] & 0x00FF0000) >> 16);
ctx->digest[(i * 4) + 3] =
(uint8_t)((ctx->buffer[i] & 0xFF000000) >> 24);
}
}
/*
* Step on 512 bits of input with the main MD5 algorithm.
*/
void md5Step(uint32_t *buffer, uint32_t *input)
{
uint32_t AA = buffer[0];
uint32_t BB = buffer[1];
uint32_t CC = buffer[2];
uint32_t DD = buffer[3];
uint32_t E;
unsigned int j;
for (unsigned int i = 0; i < 64; ++i) {
switch (i / 16) {
case 0:
E = F(BB, CC, DD);
j = i;
break;
case 1:
E = G(BB, CC, DD);
j = ((i * 5) + 1) % 16;
break;
case 2:
E = H(BB, CC, DD);
j = ((i * 3) + 5) % 16;
break;
default:
E = I(BB, CC, DD);
j = (i * 7) % 16;
break;
}
uint32_t temp = DD;
DD = CC;
CC = BB;
BB = BB + rotateLeft(AA + E + K[i] + input[j], S[i]);
AA = temp;
}
buffer[0] += AA;
buffer[1] += BB;
buffer[2] += CC;
buffer[3] += DD;
}
void md5Buf(uint8_t *input, int len, uint8_t *result)
{
MD5Context ctx;
md5Init(&ctx);
md5Update(&ctx, input, len);
md5Finalize(&ctx);
memcpy(result, ctx.digest, 16);
}

24
source/firmware/md5.h Normal file
View File

@@ -0,0 +1,24 @@
#ifndef MD5_H
#define MD5_H
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct
{
uint64_t size; // Size of input in bytes
uint32_t buffer[4]; // Current accumulation of hash
uint8_t input[64]; // Input to be used in the next step
uint8_t digest[16]; // Result of algorithm
} MD5Context;
void md5Init(MD5Context *ctx);
void md5Update(MD5Context *ctx, uint8_t *input, size_t input_len);
void md5Finalize(MD5Context *ctx);
void md5Step(uint32_t *buffer, uint32_t *input);
void md5Buf(uint8_t *input, int len, uint8_t *result);
#endif

2
source/firmware/shell.nix
View File

@@ -7,10 +7,12 @@ let cross-rv5 = import <nixpkgs> {
libc = "newlib";
};
};
flags-file = "compile_flags.txt";
in
cross-rv5.mkShell {
nativeBuildInputs = [ nixpkgs.gnumake nixpkgs.guile_3_0 ];
shellHook = ''
export NIX_SHELL_NAME="riscv"
echo | riscv32-none-elf-gcc -E -Wp,-v - 2>&1 | grep "^ .*newlib" | sed 's/^ /-I/' > ${flags-file}
'';
}