nnicolosi/Raptor
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

finally fast googlenet with correct latency artifacts for fair comparison
Validate Operations / validate-operations (push) Has been cancelled
Details

Browse Source
This commit is contained in:
NiccoloN
2026-07-29 18:20:44 +02:00
parent 060a21172e
commit 1b4f070bef
74 changed files with 2773 additions and 1311 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend-simulators/pim/pim-simulator/src/lib/instruction_set/isa.rs
+37 -24
View File
@@ -16,7 +16,7 @@ use anyhow::{Context, Result, ensure};
use rayon::prelude::*;
use paste::paste;
use std::{borrow::Cow, cell::OnceCell, collections::HashMap };
use std::{borrow::Cow, cell::OnceCell, collections::HashMap, mem::size_of};
use std::{collections::HashSet, sync::LazyLock};
macro_rules! add_name {
@@ -170,8 +170,6 @@ macro_rules! add_simd_to_map {
tmp.insert((32_usize,64_usize), ([<$id _impl>]::<f32, f64> as InstructionType));
tmp.insert((64_usize,32_usize), ([<$id _impl>]::<f64, f32> as InstructionType));
tmp.insert((64_usize,64_usize), ([<$id _impl>]::<f64, f64> as InstructionType));
//TODO WTF WHY
tmp.insert((8_usize,8_usize), ([<$id _impl>]::<f32, f32> as InstructionType));
$storage.insert($id as *const () as usize, tmp);
}
@@ -224,6 +222,14 @@ pub fn is_setbw(functor: InstructionType) -> bool {
functor as usize == setbw as *const () as usize
}
fn vector_lengths<F>(imm_len: i32) -> Result<(usize, usize)> {
let element_count: usize = imm_len.try_into().context("imm_len can not be negative")?;
let byte_len = element_count
.checked_mul(size_of::<F>())
.context("vector byte length overflow")?;
Ok((element_count, byte_len))
}
#[inline(never)]
pub fn setbw(cores: &mut CPU, data: InstructionData) -> Result<InstructionStatus> {
panic!("You are calling a placeholder, this instruction is resolved in the construction phase");
@@ -361,11 +367,11 @@ where
let r1_val = add_offset_r1(r1_val, offset_select, offset_value);
let r2_val = add_offset_r2(r2_val, offset_select, offset_value);
let rd_val = add_offset_rd(rd_val, offset_select, offset_value);
let imm_len: usize = imm_len.try_into().context("imm_len can not be negative")?;
let (element_count, byte_len) = vector_lengths::<F>(imm_len)?;
let loads = core
.reserve_load(r1_val, imm_len)?
.reserve_load(r2_val, imm_len)?
.reserve_load(r1_val, byte_len)?
.reserve_load(r2_val, byte_len)?
.execute_load::<F>()?;
let (load1, load2) = (loads[0], loads[1]);
let res: Vec<F> = load1
@@ -374,7 +380,7 @@ where
.map(|(&a, &b)| a + b)
.collect();
ensure!(
imm_len / size_of::<F>() == res.len(),
element_count == res.len(),
"vvadd generate a vector bigger thant it's requested elements"
);
let res_up: Cow<[T]> = res.as_slice().up();
@@ -405,11 +411,11 @@ where
let r1_val = add_offset_r1(r1_val, offset_select, offset_value);
let r2_val = add_offset_r2(r2_val, offset_select, offset_value);
let rd_val = add_offset_rd(rd_val, offset_select, offset_value);
let imm_len: usize = imm_len.try_into().context("imm_len can not be negative")?;
let (element_count, byte_len) = vector_lengths::<F>(imm_len)?;
let loads = core
.reserve_load(r1_val, imm_len)?
.reserve_load(r2_val, imm_len)?
.reserve_load(r1_val, byte_len)?
.reserve_load(r2_val, byte_len)?
.execute_load::<F>()?;
let (load1, load2) = (loads[0], loads[1]);
let res: Vec<F> = load1
@@ -418,7 +424,7 @@ where
.map(|(&a, &b)| a - b)
.collect();
ensure!(
imm_len / size_of::<F>() == res.len(),
element_count == res.len(),
"vvadd generate a vector bigger thant it's requested elements"
);
let res_up: Cow<[T]> = res.as_slice().up();
@@ -447,10 +453,10 @@ where
let r1_val = add_offset_r1(r1_val, offset_select, offset_value);
let r2_val = add_offset_r2(r2_val, offset_select, offset_value);
let rd_val = add_offset_rd(rd_val, offset_select, offset_value);
let imm_len: usize = imm_len.try_into().context("imm_len can not be negative")?;
let (element_count, byte_len) = vector_lengths::<F>(imm_len)?;
let loads = core
.reserve_load(r1_val, imm_len)?
.reserve_load(r2_val, imm_len)?
.reserve_load(r1_val, byte_len)?
.reserve_load(r2_val, byte_len)?
.execute_load::<F>()?;
let (load1, load2) = (loads[0], loads[1]);
let res: Vec<F> = load1
@@ -459,7 +465,7 @@ where
.map(|(&a, &b)| a * b)
.collect();
ensure!(
imm_len / size_of::<F>() == res.len(),
element_count == res.len(),
"vvadd generate a vector bigger thant it's requested elements"
);
let res_up: Cow<[T]> = res.as_slice().up();
@@ -488,9 +494,10 @@ where
let rd_val = core.register(rd);
let r1_val = add_offset_r1(r1_val, offset_select, offset_value);
let r2_val = add_offset_r2(r2_val, offset_select, offset_value);
let (_, byte_len) = vector_lengths::<F>(imm_len)?;
let loads = core
.reserve_load(r1_val, imm_len)?
.reserve_load(r2_val, imm_len)?
.reserve_load(r1_val, byte_len)?
.reserve_load(r2_val, byte_len)?
.execute_load::<F>()?;
let (load1, load2) = (loads[0], loads[1]);
let res: [F; 1] = [load1
@@ -527,10 +534,11 @@ where
let r1_val = add_offset_r1(r1_val, offset_select, offset_value);
let r2_val = add_offset_r2(r2_val, offset_select, offset_value);
let rd_val = add_offset_rd(rd_val, offset_select, offset_value);
let (_, byte_len) = vector_lengths::<F>(imm_len)?;
let loads = core
.reserve_load(r1_val, imm_len)?
.reserve_load(r2_val, imm_len)?
.reserve_load(r1_val, byte_len)?
.reserve_load(r2_val, byte_len)?
.execute_load::<F>()?;
let (load1, load2) = (loads[0], loads[1]);
let res: Vec<F> = load1
@@ -583,7 +591,8 @@ where
"Offset select cannot be different from 1"
);
let r1_val = add_offset_r1(r1_val, offset_select, offset_value);
let loads = core.reserve_load(r1_val, imm_len)?.execute_load::<F>()?;
let (_, byte_len) = vector_lengths::<F>(imm_len)?;
let loads = core.reserve_load(r1_val, byte_len)?.execute_load::<F>()?;
let load1 = loads[0];
let len = load1.len();
let res: [F; _] =
@@ -613,7 +622,8 @@ where
let rd_val = core.register(rd);
let r1_val = add_offset_r1(r1_val, offset_select, offset_value);
let rd_val = add_offset_rd(rd_val, offset_select, offset_value);
let loads = core.reserve_load(r1_val, imm_len)?.execute_load::<F>()?;
let (_, byte_len) = vector_lengths::<F>(imm_len)?;
let loads = core.reserve_load(r1_val, byte_len)?.execute_load::<F>()?;
let load1 = loads[0];
let res: Vec<F> = load1
.iter()
@@ -646,7 +656,8 @@ where
let r1_val = add_offset_r1(r1_val, offset_select, offset_value);
let rd_val = add_offset_rd(rd_val, offset_select, offset_value);
let loads = core.reserve_load(r1_val, imm_len)?.execute_load::<F>()?;
let (_, byte_len) = vector_lengths::<F>(imm_len)?;
let loads = core.reserve_load(r1_val, byte_len)?.execute_load::<F>()?;
let load1 = loads[0];
let res: Vec<F> = load1.iter().map(|&a| a.tanh()).collect();
@@ -675,7 +686,8 @@ where
let rd_val = core.register(rd);
let r1_val = add_offset_r1(r1_val, offset_select, offset_value);
let rd_val = add_offset_rd(rd_val, offset_select, offset_value);
let loads = core.reserve_load(r1_val, imm_len)?.execute_load::<F>()?;
let (_, byte_len) = vector_lengths::<F>(imm_len)?;
let loads = core.reserve_load(r1_val, byte_len)?.execute_load::<F>()?;
let load1 = loads[0];
let res: Vec<F> = load1.iter().map(|&a| a.sigm()).collect();
let res_up: Cow<[T]> = res.as_slice().up();
@@ -706,7 +718,8 @@ where
let rd_val = core.register(rd);
let r1_val = add_offset_r1(r1_val, offset_select, offset_value);
let rd_val = add_offset_rd(rd_val, offset_select, offset_value);
let loads = core.reserve_load(r1_val, imm_len)?.execute_load::<F>()?;
let (_, byte_len) = vector_lengths::<F>(imm_len)?;
let loads = core.reserve_load(r1_val, byte_len)?.execute_load::<F>()?;
let load1 = loads[0];
ensure!(!load1.is_empty(), "vsoftmax does not support empty vectors");
let max_val = load1
backend-simulators/pim/pim-simulator/src/lib/tracing/trace/tracing_isa.rs
+16 -9
View File
@@ -1,5 +1,5 @@
use crate::{tracing::trace::pretty_print, utility::add_offset_r2};
use std::fs::File;
use std::{fs::File, mem::size_of};
use crate::{
cpu::CPU,
@@ -381,7 +381,15 @@ impl Trace {
writeln!(file, "\trs1({}): {}", r1, r1_val);
writeln!(file, "\trs2({}): {}", r2, r2_val);
writeln!(file, "{} Immediate:", prefix);
writeln!(file, "\tLoad Length: {} bytes", imm_len);
let element_count: usize = imm_len.try_into().expect("imm_len can not be negative");
let byte_len = element_count
.checked_mul(size_of::<F>())
.expect("vector byte length overflow");
writeln!(
file,
"\tLoad Length: {} elements ({} bytes)",
element_count, byte_len
);
writeln!(
file,
"\toffset_select: {} offset_value: {}",
@@ -390,22 +398,21 @@ impl Trace {
let r1_final = add_offset_r1(r1_val, offset_select, offset_value);
let r2_final = add_offset_r2(r2_val, offset_select, offset_value);
let rd_final = add_offset_rd(rd_val, offset_select, offset_value);
let imm_len: usize = imm_len.try_into().expect("imm_len can not be negative");
let loads = core
.reserve_load(r1_final, imm_len)
.reserve_load(r1_final, byte_len)
.unwrap()
.reserve_load(r2_final, imm_len)
.reserve_load(r2_final, byte_len)
.unwrap()
.reserve_load(rd_final, imm_len)
.reserve_load(rd_final, byte_len)
.unwrap()
.execute_load::<F>()
.unwrap();
writeln!(file, "{} Memory:", prefix);
write!(file, "\tLocal[{}:{}](A): ", r1_final, r1_final + imm_len);
write!(file, "\tLocal[{}:{}](A): ", r1_final, r1_final + byte_len);
pretty_print::print_slice::<_,f32>(file, loads[0], 30);
write!(file, "\tLocal[{}:{}](B): ", r2_final , r2_final + imm_len);
write!(file, "\tLocal[{}:{}](B): ", r2_final , r2_final + byte_len);
pretty_print::print_slice::<_,f32>(file, loads[1], 30);
write!(file, "\tLocal[{}:{}](out): ", rd_final, rd_final+ imm_len);
write!(file, "\tLocal[{}:{}](out): ", rd_final, rd_final+ byte_len);
pretty_print::print_slice::<_,f32>(file, loads[2], 30);
if prefix == "Post" {
writeln!(file, "\n###############################################\n");