VHDL Generation

.github/dependabot.yml

@@ -7,7 +7,7 @@ updates:
     time: "04:00"
   open-pull-requests-limit: 10
   assignees:
-  - mbrobbel
+  - matthijsr
   allow:
   - dependency-type: direct
   - dependency-type: indirect

.gitignore

@@ -1,5 +1,6 @@
-# Clion
+# IDEs
 .idea
+.vscode
 
 # Book
 book/book
@@ -8,3 +9,7 @@ book/book
 /target
 **/*.rs.bk
 tarpaulin-report.html
+
+# Output
+/output
+*.cf

Cargo.toml

@@ -16,9 +16,10 @@ required-features = ["cli"]
 
 [features]
 cli = ["structopt", "parser"]
-default = ["generator", "parser"]
+default = ["generator", "parser", "stdlib"]
 generator = []
 parser = ["nom"]
+stdlib = ["generator"]
 
 [dependencies]
 log = "0.4"

src/bin/tydi.rs

@@ -2,17 +2,18 @@
 //!
 //! The Command-Line Interface binary is enabled by the `cli` feature flag.
 
-use log::{debug, info, LevelFilter};
 use std::convert::TryInto;
 use std::path::{Path, PathBuf};
+
+use log::{debug, info, LevelFilter};
+use structopt::StructOpt;
+
+use tydi::design::{Library, Project};
 use tydi::generator::vhdl::{VHDLBackEnd, VHDLConfig};
 use tydi::generator::GenerateProject;
 use tydi::UniquelyNamedBuilder;
 use tydi::{Logger, Result};
 
-use structopt::StructOpt;
-use tydi::design::{Library, Project};
-
 static LOGGER: Logger = Logger;
 
 /// Back-end options.

src/design/implementation/composer/impl_backend/mod.rs

@@ -0,0 +1,19 @@
+use crate::design::StreamletHandle;
+use crate::error::Result;
+use crate::Name;
+use core::fmt::{Debug, Formatter};
+
+///Trait for general implementation backends
+pub trait ImplementationBackend {
+    fn name(&self) -> Name;
+    fn streamlet_handle(&self) -> StreamletHandle;
+    fn connect_action(&self) -> Result<()> {
+        unimplemented!()
+    }
+}
+
+impl Debug for dyn ImplementationBackend {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        unimplemented!()
+    }
+}

src/design/implementation/composer/mod.rs

@@ -0,0 +1,110 @@
+use std::cell::{Ref, RefMut};
+use std::rc::Rc;
+
+use crate::design::implementation::Implementation;
+use crate::design::{ComponentKey, IFKey, Interface, Mode, Streamlet};
+use crate::Result;
+
+pub mod impl_backend;
+pub mod patterns;
+
+/// Traits for components in the implementation graph
+pub trait GenHDL {
+    fn gen_hdl(&self) -> Result<String>;
+}
+
+pub trait GenericComponent {
+    fn key(&self) -> ComponentKey {
+        self.streamlet().key().clone()
+    }
+    fn interfaces<'a>(&'a self) -> Box<(dyn Iterator<Item = Ref<Interface>> + 'a)> {
+        self.streamlet().interfaces()
+    }
+    fn interfaces_mut<'a>(&'a self) -> Box<(dyn Iterator<Item = RefMut<Interface>> + 'a)> {
+        unimplemented!()
+    }
+    fn streamlet(&self) -> &Streamlet;
+    fn inputs<'a>(&'a self) -> Box<(dyn Iterator<Item = Ref<Interface>> + 'a)> {
+        Box::new(self.interfaces().filter(|iface| iface.mode() == Mode::In))
+    }
+    fn outputs<'a>(&'a self) -> Box<(dyn Iterator<Item = Ref<Interface>> + 'a)> {
+        Box::new(self.interfaces().filter(|iface| iface.mode() == Mode::Out))
+    }
+    fn get_interface(&self, key: IFKey) -> Result<Ref<Interface>> {
+        self.streamlet().get_interface(key)
+    }
+    fn get_interface_mut(&self, key: IFKey) -> Result<RefMut<Interface>> {
+        self.streamlet().get_interface_mut(key)
+    }
+    fn get_implementation(&self) -> Option<Rc<Implementation>> {
+        self.streamlet().get_implementation()
+    }
+    fn connect_action(&self) -> Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::design::*;
+    use std::convert::TryFrom;
+
+    use crate::parser::nom::interface;
+    use crate::{Name, Result, UniqueKeyBuilder};
+
+    pub(crate) fn composition_test_proj() -> Result<Project> {
+        let key1 = LibKey::try_new("primitives").unwrap();
+        let key2 = LibKey::try_new("compositions").unwrap();
+        let mut lib = Library::new(key1.clone());
+
+        let mut lib_comp = Library::new(key2.clone());
+
+        let _top = lib_comp
+            .add_streamlet(
+                Streamlet::from_builder(
+                    StreamletKey::try_from("Top_level").unwrap(),
+                    UniqueKeyBuilder::new().with_items(vec![
+                        interface("in: in Stream<Bits<32>, d=1>").unwrap().1,
+                        interface("in2: in Stream<Bits<1>, d=0>").unwrap().1,
+                        interface("out: out Stream<Bits<32>, d=0>").unwrap().1,
+                    ]),
+                    None,
+                )
+                .unwrap(),
+            )
+            .unwrap();
+
+        let _map = lib
+            .add_streamlet(
+                Streamlet::from_builder(
+                    StreamletKey::try_from("Magic").unwrap(),
+                    UniqueKeyBuilder::new().with_items(vec![
+                        interface("in: in Stream<Bits<32>, d=1>").unwrap().1,
+                        interface("out: out Stream<Bits<32>, d=1>").unwrap().1,
+                    ]),
+                    None,
+                )
+                .unwrap(),
+            )
+            .unwrap();
+
+        let _test_op = lib
+            .add_streamlet(
+                Streamlet::from_builder(
+                    StreamletKey::try_from("test_op").unwrap(),
+                    UniqueKeyBuilder::new().with_items(vec![
+                        interface("in: in Stream<Bits<32>, d=0>").unwrap().1,
+                        interface("out: out Stream<Bits<32>, d=0>").unwrap().1,
+                    ]),
+                    None,
+                )
+                .unwrap(),
+            )
+            .unwrap();
+
+        let mut prj = Project::new(Name::try_new("TestProj").unwrap());
+        prj.add_lib(lib)?;
+        prj.add_lib(lib_comp)?;
+        Ok(prj)
+    }
+}