Struct MemBind 

pub struct MemBind {
    pub prefix: String,
    pub kind: MemKind,
    pub contract: Vec<String>,
    pub words_per_port: u32,
    pub dims: Vec<u32>,
}

Contract ports carried through a memory interface instead of scalar ports. The memory’s words are the listed contract ports in order, each split into words_per_port words (least significant first), so one wide port can become an array and several ports one array.

Fields

prefix: String

kind: MemKind

contract: Vec<String>

words_per_port: u32

dims: Vec<u32>

The memory’s shape when its interface takes one address per dimension, as Calyx gives a Dahlia decl x: bit<N>[R][C] (addr0 the row, addr1 the column): the words row-major. Empty: one flat address.

Implementations

impl MemBind

pub fn seq_mem(contract: &str, prefix: &str, words: u32) -> MemBind

A Calyx seq_mem holding contract port contract as words words.

pub fn seq_mem_rows( contract: &[String], prefix: &str, words_per_port: u32, ) -> MemBind

A Calyx seq_mem whose words are the contract ports contract in order, each as words_per_port words.

pub fn shaped(self, dims: &[u32]) -> MemBind

This memory addressed by one port per dimension of dims, row-major.

pub fn bram(contract: &[&str], prefix: &str, ports: u32) -> MemBind

A ports-port block RAM whose words are the contract ports contract, one each.

Trait Implementations

impl Clone for MemBind

fn clone(&self) -> MemBind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MemBind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MemBind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MemBind

fn eq(&self, other: &MemBind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MemBind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MemBind