From 3c5c877409a45155f41a08898911771e6176a86c Mon Sep 17 00:00:00 2001 From: "Wesley W. Terpstra" Date: Mon, 13 Mar 2017 19:55:27 -0700 Subject: [PATCH] tilelink2: make TLBuffer API more flexible --- src/main/scala/uncore/tilelink2/Buffer.scala | 74 ++++++++++++++------ 1 file changed, 52 insertions(+), 22 deletions(-) diff --git a/src/main/scala/uncore/tilelink2/Buffer.scala b/src/main/scala/uncore/tilelink2/Buffer.scala index 8a864ec3..b7a51c4d 100644 --- a/src/main/scala/uncore/tilelink2/Buffer.scala +++ b/src/main/scala/uncore/tilelink2/Buffer.scala @@ -8,33 +8,60 @@ import config._ import diplomacy._ import scala.math.{min,max} -// pipe is only used if a queue has depth = 1 -class TLBuffer(a: Int = 2, b: Int = 2, c: Int = 2, d: Int = 2, e: Int = 2, pipe: Boolean = true)(implicit p: Parameters) extends LazyModule +case class TLBufferParams(depth: Int, flow: Boolean, pipe: Boolean) { - require (a >= 0) - require (b >= 0) - require (c >= 0) - require (d >= 0) - require (e >= 0) + require (depth >= 0) + def isDefined = depth > 0 + def latency = if (isDefined && !flow) 1 else 0 +} + +object TLBufferParams +{ + implicit def apply(depth: Int): TLBufferParams = TLBufferParams(depth, false, false) + + val default = TLBufferParams(2) + val none = TLBufferParams(0) + val flow = TLBufferParams(1, true, false) + val pipe = TLBufferParams(1, false, true) +} + +class TLBuffer( + a: TLBufferParams, + b: TLBufferParams, + c: TLBufferParams, + d: TLBufferParams, + e: TLBufferParams)(implicit p: Parameters) extends LazyModule +{ + def this(ace: TLBufferParams, bd: TLBufferParams)(implicit p: Parameters) = this(ace, bd, ace, bd, ace) + def this(abcde: TLBufferParams)(implicit p: Parameters) = this(abcde, abcde) + def this()(implicit p: Parameters) = this(TLBufferParams.default) val node = TLAdapterNode( - clientFn = { p => p.copy(minLatency = p.minLatency + min(1,b) + min(1,c)) }, - managerFn = { p => p.copy(minLatency = p.minLatency + min(1,a) + min(1,d)) }) + clientFn = { p => p.copy(minLatency = p.minLatency + b.latency + c.latency) }, + managerFn = { p => p.copy(minLatency = p.minLatency + a.latency + d.latency) }) lazy val module = new LazyModuleImp(this) { val io = new Bundle { val in = node.bundleIn val out = node.bundleOut } - + + def buffer[T <: Data](config: TLBufferParams, data: DecoupledIO[T]): DecoupledIO[T] = { + if (config.isDefined) { + Queue(data, config.depth, pipe=config.pipe, flow=config.flow) + } else { + data + } + } + ((io.in zip io.out) zip (node.edgesIn zip node.edgesOut)) foreach { case ((in, out), (edgeIn, edgeOut)) => - if (a>0) { out.a <> Queue(in .a, a, pipe && a<2) } else { out.a <> in.a } - if (d>0) { in .d <> Queue(out.d, d, pipe && d<2) } else { in.d <> out.d } + out.a <> buffer(a, in .a) + in .d <> buffer(d, out.d) if (edgeOut.manager.anySupportAcquireB && edgeOut.client.anySupportProbe) { - if (b>0) { in .b <> Queue(out.b, b, pipe && b<2) } else { in.b <> out.b } - if (c>0) { out.c <> Queue(in .c, c, pipe && c<2) } else { out.c <> in.c } - if (e>0) { out.e <> Queue(in .e, e, pipe && e<2) } else { out.e <> in.e } + in .b <> buffer(b, out.b) + out.c <> buffer(c, in .c) + out.e <> buffer(e, in .e) } else { in.b.valid := Bool(false) in.c.ready := Bool(true) @@ -50,13 +77,16 @@ class TLBuffer(a: Int = 2, b: Int = 2, c: Int = 2, d: Int = 2, e: Int = 2, pipe: object TLBuffer { // applied to the TL source node; y.node := TLBuffer(x.node) - def apply() (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(2)(x) - def apply(entries: Int) (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(entries, true)(x) - def apply(entries: Int, pipe: Boolean) (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(entries, entries, pipe)(x) - def apply(ace: Int, bd: Int) (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(ace, bd, true)(x) - def apply(ace: Int, bd: Int, pipe: Boolean)(x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(ace, bd, ace, bd, ace, pipe)(x) - def apply(a: Int, b: Int, c: Int, d: Int, e: Int, pipe: Boolean = true)(x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = { - val buffer = LazyModule(new TLBuffer(a, b, c, d, e, pipe)) + def apply() (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(TLBufferParams.default)(x) + def apply(abcde: TLBufferParams) (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(abcde, abcde)(x) + def apply(ace: TLBufferParams, bd: TLBufferParams)(x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(ace, bd, ace, bd, ace)(x) + def apply( + a: TLBufferParams, + b: TLBufferParams, + c: TLBufferParams, + d: TLBufferParams, + e: TLBufferParams)(x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = { + val buffer = LazyModule(new TLBuffer(a, b, c, d, e)) buffer.node := x buffer.node }