cpu/crates/cpu/src/config.rs

// SPDX-License-Identifier: LGPL-3.0-or-later
// See Notices.txt for copyright information
use crate::{
    instruction::{CONST_ZERO_UNIT_NUM, MOpTrait, PRegNum, RenamedMOp, UnitNum, UnitOutRegNum},
    unit::{
        UnitCancelInput, UnitKind, UnitOutputWrite,
        unit_base::{UnitForwardingInfo, UnitToRegAlloc},
    },
};
use fayalite::prelude::*;
use serde::{Deserialize, Serialize};
use std::num::NonZeroUsize;

#[derive(Clone, Eq, PartialEq, Hash, Debug, Serialize, Deserialize)]
#[non_exhaustive]
pub struct UnitConfig {
    pub kind: UnitKind,
    /// max number of instructions that can be in-flight through this unit at any point in time.
    pub max_in_flight: Option<NonZeroUsize>,
}

impl UnitConfig {
    pub fn new(kind: UnitKind) -> Self {
        Self {
            kind,
            max_in_flight: None,
        }
    }
}

#[derive(Clone, Eq, PartialEq, Hash, Debug, Serialize, Deserialize)]
#[non_exhaustive]
pub struct CpuConfig {
    pub units: Vec<UnitConfig>,
    pub out_reg_num_width: usize,
    pub fetch_width: NonZeroUsize,
    pub max_branches_per_fetch: NonZeroUsize,
    pub max_fetches_in_flight: NonZeroUsize,
    pub log2_fetch_width_in_bytes: u8,
    pub log2_cache_line_size_in_bytes: u8,
    pub log2_l1_i_cache_line_count: u8,
    pub l1_i_cache_max_misses_in_flight: NonZeroUsize,
    /// default value for [`UnitConfig::max_in_flight`]
    pub default_unit_max_in_flight: NonZeroUsize,
    pub rob_size: NonZeroUsize,
}

impl CpuConfig {
    pub const DEFAULT_OUT_REG_NUM_WIDTH: usize = 4;
    pub const DEFAULT_FETCH_WIDTH: NonZeroUsize = {
        let Some(v) = NonZeroUsize::new(1) else {
            unreachable!();
        };
        v
    };
    pub const DEFAULT_MAX_BRANCHES_PER_FETCH: NonZeroUsize = {
        let Some(v) = NonZeroUsize::new(1) else {
            unreachable!();
        };
        v
    };
    pub const DEFAULT_MAX_FETCHES_IN_FLIGHT: NonZeroUsize = {
        let Some(v) = NonZeroUsize::new(16) else {
            unreachable!();
        };
        v
    };
    pub const DEFAULT_LOG2_FETCH_WIDTH_IN_BYTES: u8 = 3;
    pub const DEFAULT_LOG2_CACHE_LINE_SIZE_IN_BYTES: u8 = 6;
    pub const DEFAULT_LOG2_L1_I_CACHE_LINE_COUNT: u8 = 8;
    pub const DEFAULT_L1_I_CACHE_MAX_MISSES_IN_FLIGHT: NonZeroUsize = {
        let Some(v) = NonZeroUsize::new(2) else {
            unreachable!();
        };
        v
    };
    pub const DEFAULT_UNIT_MAX_IN_FLIGHT: NonZeroUsize = {
        let Some(v) = NonZeroUsize::new(8) else {
            unreachable!();
        };
        v
    };
    pub fn new(units: Vec<UnitConfig>, rob_size: NonZeroUsize) -> Self {
        Self {
            units,
            out_reg_num_width: Self::DEFAULT_OUT_REG_NUM_WIDTH,
            fetch_width: Self::DEFAULT_FETCH_WIDTH,
            max_branches_per_fetch: Self::DEFAULT_MAX_BRANCHES_PER_FETCH,
            max_fetches_in_flight: Self::DEFAULT_MAX_FETCHES_IN_FLIGHT,
            log2_fetch_width_in_bytes: Self::DEFAULT_LOG2_FETCH_WIDTH_IN_BYTES,
            log2_cache_line_size_in_bytes: Self::DEFAULT_LOG2_CACHE_LINE_SIZE_IN_BYTES,
            log2_l1_i_cache_line_count: Self::DEFAULT_LOG2_L1_I_CACHE_LINE_COUNT,
            l1_i_cache_max_misses_in_flight: Self::DEFAULT_L1_I_CACHE_MAX_MISSES_IN_FLIGHT,
            default_unit_max_in_flight: Self::DEFAULT_UNIT_MAX_IN_FLIGHT,
            rob_size,
        }
    }
    pub fn non_const_unit_nums(&self) -> std::ops::Range<usize> {
        (CONST_ZERO_UNIT_NUM + 1)..(self.units.len() + 1)
    }
    pub fn unit_num_width(&self) -> usize {
        UInt::range(CONST_ZERO_UNIT_NUM..self.non_const_unit_nums().end).width()
    }
    pub fn unit_num(&self) -> UnitNum<DynSize> {
        UnitNum[self.unit_num_width()]
    }
    pub fn unit_out_reg_num(&self) -> UnitOutRegNum<DynSize> {
        UnitOutRegNum[self.out_reg_num_width]
    }
    pub fn p_reg_num(&self) -> PRegNum<DynSize, DynSize> {
        PRegNum[self.unit_num_width()][self.out_reg_num_width]
    }
    pub fn p_reg_num_width(&self) -> usize {
        self.unit_num_width() + self.out_reg_num_width
    }
    pub fn renamed_mop_in_unit(&self) -> RenamedMOp<UnitOutRegNum<DynSize>, DynSize> {
        RenamedMOp[self.unit_out_reg_num()][self.p_reg_num_width()]
    }
    pub fn unit_output_write(&self) -> UnitOutputWrite<DynSize> {
        UnitOutputWrite[self.out_reg_num_width]
    }
    pub fn unit_output_writes(&self) -> Array<HdlOption<UnitOutputWrite<DynSize>>> {
        Array[HdlOption[self.unit_output_write()]][self.non_const_unit_nums().len()]
    }
    pub fn unit_cancel_input(&self) -> UnitCancelInput<DynSize> {
        UnitCancelInput[self.out_reg_num_width]
    }
    pub fn unit_forwarding_info(&self) -> UnitForwardingInfo<DynSize, DynSize, DynSize> {
        UnitForwardingInfo[self.unit_num_width()][self.out_reg_num_width]
            [self.non_const_unit_nums().len()]
    }
    pub fn unit_max_in_flight(&self, unit_index: usize) -> NonZeroUsize {
        self.units[unit_index]
            .max_in_flight
            .unwrap_or(self.default_unit_max_in_flight)
    }
    pub fn unit_to_reg_alloc<
        MOp: Type + MOpTrait<DestReg = UnitOutRegNum<DynSize>, SrcRegWidth = DynSize>,
        ExtraOut: Type,
    >(
        &self,
        mop_ty: MOp,
        extra_out_ty: ExtraOut,
    ) -> UnitToRegAlloc<MOp, ExtraOut, DynSize, DynSize, DynSize> {
        assert_eq!(
            mop_ty.dest_reg_ty(),
            self.unit_out_reg_num(),
            "inconsistent types",
        );
        UnitToRegAlloc[mop_ty][extra_out_ty][self.unit_num_width()][self.out_reg_num_width]
            [self.non_const_unit_nums().len()]
    }
    pub fn fetch_width_in_bytes(&self) -> usize {
        1usize
            .checked_shl(self.log2_fetch_width_in_bytes.into())
            .expect("log2_fetch_width_in_bytes is too big")
    }
    pub fn cache_line_size_in_bytes(&self) -> usize {
        1usize
            .checked_shl(self.log2_cache_line_size_in_bytes.into())
            .expect("log2_cache_line_size_in_bytes is too big")
    }
    pub fn log2_fetches_per_cache_line(&self) -> usize {
        self.log2_cache_line_size_in_bytes
            .checked_sub(self.log2_fetch_width_in_bytes)
            .expect("cache line size in bytes must not be smaller than fetch width in bytes")
            .into()
    }
    pub fn fetches_per_cache_line(&self) -> usize {
        self.log2_fetches_per_cache_line()
            .try_into()
            .ok()
            .and_then(|v| 1usize.checked_shl(v))
            .expect("log2_fetches_per_cache_line is too big")
    }
    pub fn l1_i_cache_line_count(&self) -> usize {
        1usize
            .checked_shl(self.log2_l1_i_cache_line_count.into())
            .expect("log2_l1_i_cache_line_count is too big")
    }
    pub fn log2_l1_i_cache_size_in_bytes(&self) -> usize {
        self.log2_l1_i_cache_line_count as usize + self.log2_cache_line_size_in_bytes as usize
    }
    pub fn l1_i_cache_size_in_bytes(&self) -> usize {
        1usize
            .checked_shl(self.log2_l1_i_cache_size_in_bytes() as _)
            .expect("L1 I-Cache is too big")
    }
}

#[hdl(get(|c| c.fetch_width.get()))]
pub type CpuConfigFetchWidth<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.fetch_width.get() * 2))]
pub type TwiceCpuConfigFetchWidth<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.max_branches_per_fetch.get()))]
pub type CpuConfigMaxBranchesPerFetch<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.max_fetches_in_flight.get()))]
pub type CpuConfigMaxFetchesInFlight<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.log2_fetch_width_in_bytes.into()))]
pub type CpuConfigLog2FetchWidthInBytes<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.fetch_width_in_bytes()))]
pub type CpuConfigFetchWidthInBytes<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.log2_fetches_per_cache_line()))]
pub type CpuConfigLog2FetchesPerCacheLine<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.fetches_per_cache_line()))]
pub type CpuConfigFetchesPerCacheLine<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.log2_cache_line_size_in_bytes.into()))]
pub type CpuConfigLog2CacheLineSizeInBytes<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.cache_line_size_in_bytes()))]
pub type CpuConfigCacheLineSizeInBytes<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.log2_l1_i_cache_line_count.into()))]
pub type CpuConfigLog2L1ICacheLineCount<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.l1_i_cache_line_count()))]
pub type CpuConfigL1ICacheLineCount<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.log2_l1_i_cache_size_in_bytes()))]
pub type CpuConfigLog2L1ICacheSizeInBytes<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.l1_i_cache_size_in_bytes()))]
pub type CpuConfigL1ICacheSizeInBytes<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.l1_i_cache_max_misses_in_flight.get()))]
pub type CpuConfigL1ICacheMaxMissesInFlight<C: PhantomConstGet<CpuConfig>> = DynSize;

#[hdl(get(|c| c.rob_size.get()))]
pub type CpuConfigRobSize<C: PhantomConstGet<CpuConfig>> = DynSize;

pub trait PhantomConstCpuConfig:
    PhantomConstGet<CpuConfig>
    + Into<PhantomConst<CpuConfig>>
    + From<PhantomConst<CpuConfig>>
    + Type
    + ToSimValue<Type = Self>
    + ToExpr<Type = Self>
{
}

impl PhantomConstCpuConfig for PhantomConst<CpuConfig> {}