bics
/
actlib_dataflow_neuro
18
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

init rewriting tree gates

This commit is contained in:
alexmadison 2022-02-21 15:54:10 +01:00
parent 30ffd8b16f
commit 5928dc9f42
1 changed files with 229 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

229
dataflow_neuro/treegates.act Normal file
View File

@ -0,0 +1,229 @@
/*************************************************************************
*
* This file is part of ACT dataflow neuro library
*
* Copyright (c) 2022 University of Groningen - Ole Richter
* Copyright (c) 2021 Rajit Manohar
*
* This source describes Open Hardware and is licensed under the CERN-OHL-W v2 or later
*
* You may redistribute and modify this documentation and make products
* using it under the terms of the CERN-OHL-W v2 (https:/cern.ch/cern-ohl).
* This documentation is distributed WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTY, INCLUDING OF MERCHANTABILITY, SATISFACTORY QUALITY
* AND FITNESS FOR A PARTICULAR PURPOSE. Please see the CERN-OHL-W v2
* for applicable conditions.
*
* Source location: https://git.web.rug.nl/bics/actlib_dataflow_neuro
*
* As per CERN-OHL-W v2 section 4.1, should You produce hardware based on
* these sources, You must maintain the Source Location visible in its
* documentation.
*
**************************************************************************
namespace std {
export namespace gates {
/*
* Build an OR-gate tree (NOR/NAND/optional INV)
*/
export template<pint N; pbool invert>
defproc ortree (bool? in[N]; bool out)
{
bool tout;
{ N > 0 : "What?" };
pint i, end, j;
pbool isinv;
isinv = false;
i = 0;
end = N-1;
/* dynamic array that holds all the nodes in the completion tree */
bool tmp[N];
(k:N:tmp[k] = in[k];)
/* Invariant: i <= end */
*[ i != end ->
/*
* Invariant: tmp[i..end] has the current signals that need to be
* combined together, and "isinv" specifies if they are the inverted
* sense or not
*/
j = 0;
*[ i < end ->
/*-- there are still signals that need to be combined --*/
j = j + 1;
bool tmp[end+j..end+j];
[ i+2 >= end ->
/*-- last piece: use either a 2 or 3 input NAND/NOR gate --*/
[isinv ->
prs { (&k:i..end:tmp[k]) => tmp[end+j]- }
[] else ->
prs { (|k:i..end:tmp[k]) => tmp[end+j]- }
]
i = end;
[] else ->
/*-- more to come; so use a two input C-element --*/
[isinv ->
prs { (&k:i..i+1:tmp[k]) => tmp[end+j]- }
[] else ->
prs { (|k:i..i+1:tmp[k]) => tmp[end+j]- }
]
i = i + 2;
]
sizing {
leak_adjust <- 1;
p_n_mode <- 1;
tmp[end+j]{-1}
}
]
/*-- we just added an inverting layer --*/
isinv = ~isinv;
/*-- update range that has to be combined --*/
i = end+1;
end = end+j;
j = 0;
]
isinv = invert ? ~isinv : isinv;
/*-- invert the signal if needed --*/
[isinv -> prs { tmp[end] => out- }
[] else -> tmp[end] = out;
]
[isinv ->
sizing {
leak_adjust <- 1;
p_n_mode <- 1;
out{-1}
}
]
}
/*
* Build a completion tree using a combination of 2-input and 3-input
* C-elements
*/
export template<pint N; pbool invert>
defproc ctree (bool? in[N]; bool out)
{
bool tout;
{ N > 0 : "What?" };
pint i, end, j;
pbool isinv;
isinv = invert;
i = 0;
end = N-1;
pint lenTree2Count, lenTree3Count;
/* Pre"calculate" the number of C cells required, look below if confused */
*[ i != end ->
j = 0;
*[ i < end ->
j = j + 1;
[ i+1 >= end ->
i = end;
lenTree2Count = lenTree2Count +1;
[] i+2 >= end ->
i = end;
lenTree3Count = lenTree3Count +1;
[] else ->
i = i + 2;
lenTree2Count = lenTree2Count +1;
]
]
/*-- update range that has to be combined --*/
i = end+1;
end = end+j;
j = 0;
]
/* array that holds ALL the nodes in the completion tree */
bool tmp[end];
(k:N:tmp[k] = in[k];)
/* array to hold the actual C-elments, either A2C or A3C */
A_2C_B_X1 C2Els[lenTree2Count];
A_3C_B_X1 C3Els[lenTree3Count];
/* Reset the variables we just stole lol */
i = 0;
end = N-1;
j = 0;
pint tree2Index = 0;
pint tree3Index = 0;
/* Invariant: i <= end */
*[ i != end ->
/*
* Invariant: tmp[i..end] has the current signals that need to be
* combined together, and "isinv" specifies if they are the inverted
* sense or not
*/
j = 0;
*[ i < end ->
/*-- there are still signals that need to be combined --*/
j = j + 1;
bool tmp[end+j..end+j];
[ i+1 >= end ->
/*-- last piece: use either a 2 input C-element --*/
C2Els[tree2Index](.c1 = tmp[i], .c2 = tmp[i+1], .y = tmp[end+j])
tree2Index = tree2Index +1;
i = end;
[] i+2 >= end ->
/*-- last piece: use either a 3 input C-element --*/
C3Els[tree3Index](.c1 = tmp[i], .c2 = tmp[i+1], .c3 = tmp[i+2], .y = tmp[end+j])
tree3Index = tree3Index +1;
i = end;
[] else ->
/*-- more to come; so use a two input C-element --*/
C2Els[tree2Index](.c1 = tmp[i], .c2 = tmp[i+1], .y = tmp[end+j])
tree2Index = tree2Index +1;
i = i + 2;
]
]
/*-- update range that has to be combined --*/
i = end+1;
end = end+j;
j = 0;
]
}
export template<pint N>
defproc sigbuf (bool? in; bool! out; power supply)
{
{ N >= 0 : "sigbuf: parameter error" };
{ N <= 43 : "sigbuf: parameter error, N too big" };
/* -- just use a sized driver here -- */
[ N <= 4 ->
BUF_X1 buf;
[] N >= 5 & N <= 7 ->
BUF_X2 buf;
[] N >= 8 & N <= 10 ->
BUF_X3 buf;
[] N >= 11 & N <= 14 ->
BUF_X4 buf;
[] N >= 15 & N <= 18 ->
BUF_X6 buf;
[] N >= 19 & N <= 29 ->
BUF_X8 buf;
[] N >= 30 & N <= 42 ->
BUF_X12 buf;
]
buf.a = in;
buf.y = out;
buf.vdd = supply.vdd;
buf.vss = supply.vss;
}