new primitives to implement space and time decimation. also, a counter

Author: rachitnigam

primitives/reshape.fil

@@ -156,4 +156,34 @@ comp SplitWire[W, N, ?L=1]<'G: L>(
       spl := new SplitWire[W, N-1, L]<'G>(rem.out);
       out{1..N} = spl.out{0..N-1};
    }
-}
+}
+
+// Decimates inputs in space. A module provides N inputs and this module
+// returns the first one as its output.
+comp DecimateSpace[W, N]<'G: 1>(
+  in[W]: ['G, 'G+1] W
+) -> (
+  out: ['G, 'G+1] W
+) where N > 0 {
+  out = in{0};
+}
+
+// Decimates inputs in time using a valid tag. Valid is asserted every N
+// cycles an input is sent into the module (i.e., `en` is asserted).
+comp DecimateTime[W, N]<'G: 1>(
+  en: interface['G],
+  in: ['G, 'G+1] W
+) -> (
+  out: ['G, 'G+1] W,
+  valid: ['G, 'G+1] 1
+) where W > 0, N > 0 {
+  let Bits = log2(N) + 1;
+  assume Bits > 0;
+
+  counter := new Counter[Bits, N]<'G>();
+  one := new Const[Bits, 1]<'G>();
+  eq := new Eq[Bits]<'G>(counter.out, one.out);
+
+  out = in;
+  valid = eq.out;
+}

primitives/state.fil

@@ -75,4 +75,31 @@ comp Shift[W, D, ?N=1]<'G: 1>(
    out_split := new SplitWire[W, N]<'G+D>(f{D});
    out{0..N} = out_split.out{0..N};
 }
-/* ANCHOR_END: shift */
+/* ANCHOR_END: shift */
+
+// A counter that counts up by one every time `en` is asserted and resets
+// when it reaches the value `N`.
+comp Counter[W, N]<'G:1>(
+  en: interface['G]
+) -> (out: ['G, 'G+1] W) with {
+  let Out = log2(N) + 1;
+} where W > 0 {
+  // Needed to ensure that N can fit within W.
+  let Bits = log2(N)+1;
+  assume Bits > 0;
+  assume W >= Bits;
+
+  one := new Const[Bits, 1]<'G>();
+  counter := new Prev[Bits, 1]<'G>(mux.out);
+  add := new Add[Bits]<'G>(counter.prev, one.out);
+
+  max := new Const[Bits, N]<'G>();
+  eq := new Eq[Bits]<'G>(counter.prev, max.out);
+
+  zero := new Const[Bits, 0]<'G>();
+  mux := new Mux[Bits]<'G>(eq.out, counter.prev, zero.out);
+
+  resized := new ZeroExtend[Bits, W]<'G>(counter.prev);
+
+  out = resized.out;
+}