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

Broken pim-sim commit

Browse Source
This commit is contained in:
ilgeco
2026-05-13 13:32:09 +02:00
parent 41de3cb150
commit ad56888b0b
6 changed files with 97 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend-simulators/pim/pim-simulator/Cargo.toml
+1
View File
@@ -34,3 +34,4 @@ plotly = {version="0.8", optional=true}
rayon = "1.12.0"
faer = "0.24.0"
faer-traits = "0.24.0"
mimalloc = "0.1.50"
backend-simulators/pim/pim-simulator/src/bin/pim-simulator/main.rs
+19 -20
View File
@@ -1,3 +1,8 @@
use mimalloc::MiMalloc;
#[global_allocator]
static GLOBAL: MiMalloc = MiMalloc;
use anyhow::{Context, Result, bail};
use clap::Parser;
use glob::glob;
@@ -7,8 +12,8 @@ use pimcore::memory_manager::CoreMemory;
use pimcore::tracing::TRACER;
use serde_json::Value;
use std::collections::HashMap;
use std::fs::{self, read_link};
use std::io::Write;
use std::fs::{self, File, read_link};
use std::io::{ BufReader, Write};
use std::path::PathBuf;
/// Program to simulate core execution configuration
@@ -44,12 +49,12 @@ fn main() -> Result<()> {
let args = Args::parse();
let config_json = retrive_config(&args)?;
let core_jsons = retrive_cores(&args)?;
let core_jsons = retrive_cores_file(&args)?;
let memory = retrive_memory(&args)?;
let global_crossbars = get_crossbars(&config_json, &args).unwrap();
let crossbars = map_crossbars_to_cores(&config_json, &args, &global_crossbars);
let mut executor =
json_to_executor::json_to_executor(config_json, core_jsons.iter(), crossbars);
json_to_executor::json_to_executor(config_json, core_jsons, crossbars);
set_memory(&mut executor, memory);
TRACER
.lock()
@@ -140,8 +145,7 @@ fn get_crossbars(config: &Value, args: &Args) -> anyhow::Result<HashMap<String,
}
let bytes = std::fs::read(weight_file.path()).expect("Failed to read binary file");
let mut crossbar =
Crossbar::new(column_corssbar * 4, rows_crossbar, CoreMemory::new());
let mut crossbar = Crossbar::new(column_corssbar * 4, rows_crossbar, CoreMemory::new());
crossbar.execute_store(&bytes).unwrap();
res.insert(
weight_file
@@ -214,15 +218,13 @@ fn retrive_memory(args: &Args) -> Result<Vec<u8>> {
Ok(memory_vector)
}
fn retrive_cores(args: &Args) -> Result<Vec<Value>, anyhow::Error> {
let mut core_jsons: Vec<Value> = Vec::new();
fn retrive_cores_file(args: &Args) -> Result<Vec<BufReader<File>>, anyhow::Error> {
let mut core_file_reader: Vec<BufReader<File>> = Vec::new();
if let Some(cores_override) = &args.cores {
for core in cores_override {
let content = fs::read_to_string(core)
.with_context(|| format!("Failed to read core file: {:?}", cores_override))?;
let json: Value =
serde_json::from_str(&content).context("Failed to parse core json override")?;
core_jsons.push(json);
let file = File::open(core)?;
let reader = BufReader::new(file);
core_file_reader.push(reader);
}
} else if let Some(folder) = args.folder.as_ref() {
let pattern = folder.join("core*.json");
@@ -242,17 +244,14 @@ fn retrive_cores(args: &Args) -> Result<Vec<Value>, anyhow::Error> {
bail!("No core*.json files found in {:?}", folder);
}
for entry in paths {
let path = entry;
let content = fs::read_to_string(&path)
.with_context(|| format!("Failed to read core file: {:?}", path))?;
let json: Value = serde_json::from_str(&content)
.with_context(|| format!("Failed to parse JSON in {:?}", path))?;
core_jsons.push(json);
let file = File::open(entry)?;
let reader = BufReader::new(file);
core_file_reader.push(reader);
}
} else {
bail!("Either --core or --folder must be provided to find core definitions.");
}
Ok(core_jsons)
Ok(core_file_reader)
}
fn retrive_config(args: &Args) -> Result<Value, anyhow::Error> {
backend-simulators/pim/pim-simulator/src/lib/instruction_set/isa.rs
+11 -2
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 };
use std::{collections::HashSet, sync::LazyLock};
macro_rules! add_name {
@@ -35,7 +35,7 @@ macro_rules! add_name_simd {
};
}
static NAMES: LazyLock<HashMap<usize, &'static str>> = LazyLock::new(|| {
pub static NAMES: LazyLock<HashMap<usize, &'static str>> = LazyLock::new(|| {
let mut hash = HashMap::new();
add_name!(hash, sldi);
add_name!(hash, sld);
@@ -775,10 +775,19 @@ pub fn lmv(cores: &mut CPU, data: InstructionData) -> Result<InstructionStatus>
Ok(InstructionStatus::Completed)
}
pub fn isa_send(functor : usize) -> bool{
(send as *const () as usize) == functor
}
pub fn send(cores: &mut CPU, data: InstructionData) -> Result<InstructionStatus> {
Ok(InstructionStatus::Sending(data))
}
pub fn isa_recv(functor : usize) -> bool{
println!("{} {} ", functor, (recv as *const () as usize));
(recv as *const () as usize) == functor
}
pub fn recv(cores: &mut CPU, data: InstructionData) -> Result<InstructionStatus> {
Ok(InstructionStatus::Reciving(data))
}
backend-simulators/pim/pim-simulator/src/lib/instruction_set/mod.rs
+1 -1
View File
@@ -14,7 +14,7 @@ pub mod helper;
#[derive(Clone, Copy, Debug)]
pub struct Instruction {
pub data: InstructionData,
functor: InstructionType,
pub functor: InstructionType,
}
#[derive(Debug, Clone, Copy, Default)]
backend-simulators/pim/pim-simulator/src/lib/json_to_instruction/json_to_executor.rs
+17 -15
View File
@@ -1,11 +1,15 @@
use core::panic;
use std::collections::HashMap;
use std::io::{Read, Write};
use std::{collections::HashMap, fs::File, io::BufReader};
use serde_json::{Map, Value};
use serde_json::{Deserializer, Map, Value};
use crate::{
CoreInstructionsBuilder, Executable,
cpu::{CPU, crossbar::{self, Crossbar}},
cpu::{
CPU,
crossbar::{self, Crossbar},
},
instruction_set::{
InstructionsBuilder,
instruction_data::{self, InstructionData, InstructionDataBuilder},
@@ -14,11 +18,10 @@ use crate::{
memory_manager::type_traits::TryToUsize,
};
pub fn json_to_executor<'a, 'b>(
config: Value,
mut cores: impl Iterator<Item = &'b Value>,
crossbars : Vec<Vec<&'a Crossbar>>
mut cores: Vec<BufReader<File>>,
crossbars: Vec<Vec<&'a Crossbar>>,
) -> Executable<'a> {
let cell_precision = config.get("cell_precision").unwrap().as_i64().unwrap() as i32;
let core_cnt = config.get("core_cnt").unwrap().as_i64().unwrap() as i32 - 1;
@@ -29,19 +32,18 @@ pub fn json_to_executor<'a, 'b>(
let mut cpu = CPU::new(core_cnt, crossbars);
let mut core_insts_builder = CoreInstructionsBuilder::new(core_cnt as usize);
cores.next();
// Note: cores[0] is intentionally empty and discarded
for core_indx in 1..=core_cnt {
let mut insts_builder = InstructionsBuilder::new();
let mut inst_data_builder = InstructionDataBuilder::new();
inst_data_builder.set_core_indx(core_indx).fix_core_indx();
let json_core = cores
.next()
.unwrap_or_else(|| panic!("cores files less than {}", core_indx ));
let json_core_insts = json_core
.as_array()
.unwrap_or_else(|| panic!("core{} has not a list of instruction", core_indx));
for json_inst in json_core_insts {
json_isa::json_to_instruction(&mut insts_builder, &mut inst_data_builder, json_inst);
let stream = Deserializer::from_reader(&mut cores[core_indx as usize]).into_iter::<Value>();
for (i, json_inst_result) in stream.enumerate() {
let json_inst = json_inst_result.expect("Failed to parse instruction");
// Pass the single Value to your parser
json_isa::json_to_instruction(&mut insts_builder, &mut inst_data_builder, &json_inst);
drop(json_inst);
}
core_insts_builder.set_core(core_indx, insts_builder.build());
}
backend-simulators/pim/pim-simulator/src/lib/pimcore.rs
+48 -4
View File
@@ -4,7 +4,10 @@ use std::time::{Duration, SystemTime};
use crate::{
cpu::CPU,
instruction_set::{Instruction, InstructionStatus, Instructions, isa::functor_to_name},
instruction_set::{
Instruction, InstructionStatus, Instructions,
isa::{NAMES, functor_to_name, isa_recv, isa_send},
},
memory_manager::type_traits::TryToUsize,
send_recv::{SendRecv, handle_send_recv},
tracing::TRACER,
@@ -144,8 +147,9 @@ impl<'a> Executable<'a> {
cpu_progressed = 0;
*program_counter += 1;
}
if (now.elapsed().unwrap() > Duration::from_secs(1)) {
print_status(&cores_instructions);
if (now.elapsed().unwrap() > Duration::from_secs(5)) {
print_status(cores_instructions);
check_cycle(cpu, cores_instructions, send_recv);
now = SystemTime::now();
}
}
@@ -170,7 +174,7 @@ impl<'a> Executable<'a> {
}
print_status(cores_instructions);
#[cfg(feature = "profile_time")]
#[cfg(feature = "profile_time")]
TRACER.lock().unwrap().report();
}
@@ -193,6 +197,46 @@ impl<'a> Executable<'a> {
}
}
fn check_cycle(cpu: &mut CPU, cores_instructions: &[CoreInstructions], send_recv: &mut SendRecv) {
//println!("PRINTAAA");
//*PRINTAAA.lock().unwrap() = true;
//(inst.functor)(cpu, inst.data);
//*PRINTAAA.lock().unwrap() = false;
//
println!("NAMES");
for (a,n) in NAMES.iter(){
println!("{} {}", a, n);
}
let mut i = 0;
for CoreInstructions {
instructions,
program_counter,
} in cores_instructions
{
if *program_counter >= instructions.len() {
continue;
}
let Instruction { data, functor } = instructions[*program_counter];
let functor_address = functor as usize;
print!("Core {} ", i);
i += 1;
match (isa_recv(functor_address), isa_send(functor_address)) {
(true, false) => {
let (receiver, sender) = data.get_core_immcore();
println!("{} <- {}", receiver, sender);
}
(false, true) => {
let (sender, receiver) = data.get_core_immcore();
println!("{} -> {}", receiver, sender);
}
_ => {}
}
}
}
fn handle_wait_sync<'a, 'b, 'c>(
cpu: &'b mut CPU<'a>,
core_instructions: &'c mut [CoreInstructions],