From 88234ead0d973fc3ed75f96097fc643a0db9220c Mon Sep 17 00:00:00 2001 From: "Wesley W. Terpstra" Date: Mon, 6 Nov 2017 11:53:09 -0800 Subject: [PATCH] tilelink: generalize ErrorEvaluator to more than just address patterns --- src/main/scala/tilelink/ErrorEvaluator.scala | 46 +++++++++++++------- 1 file changed, 31 insertions(+), 15 deletions(-) diff --git a/src/main/scala/tilelink/ErrorEvaluator.scala b/src/main/scala/tilelink/ErrorEvaluator.scala index 2a1bdb4b..1bcd71a0 100644 --- a/src/main/scala/tilelink/ErrorEvaluator.scala +++ b/src/main/scala/tilelink/ErrorEvaluator.scala @@ -7,34 +7,50 @@ import freechips.rocketchip.config.Parameters import freechips.rocketchip.diplomacy._ import freechips.rocketchip.util._ +// Check if a request satisfies some interesting property +class RequestPattern(test: TLBundleA => Bool) +{ + def apply(a: TLBundleA) = test(a) +} + +object RequestPattern +{ + // Does the request address range overlap a particular pattern of addresses? + def overlaps(pattern: Seq[AddressSet])(a: TLBundleA) = { + val amask = UIntToOH1(a.size, a.params.addressBits) + val abase = a.address + pattern.map { case p => + val pbase = UInt(p.base) + val pmask = UInt(p.mask & ((BigInt(1) << a.params.addressBits) - 1)) + (amask | pmask | ~(abase ^ pbase)).andR + }.reduce(_ || _) + } + + implicit def apply(pattern: Seq[AddressSet]): RequestPattern = new RequestPattern(overlaps(pattern) _) +} + // An ErrorEvaluator is used for test harnesses. -// It creates errors in transactions which overlap an address in pattern. +// It creates errors in transactions which match the provided test function. // If testOn is true, it will assert fail if these transactions do not already error. // If testOff is true, it will assert fail if these transactions otherwise error. // This helps when building unit tests to confirm that errors are propagated correctly. -class TLErrorEvaluator(pattern: Seq[AddressSet], testOn: Boolean, testOff: Boolean)(implicit p: Parameters) extends LazyModule +class TLErrorEvaluator(test: RequestPattern, testOn: Boolean, testOff: Boolean)(implicit p: Parameters) extends LazyModule { val node = TLAdapterNode() lazy val module = new LazyModuleImp(this) { (node.in zip node.out) foreach { case ((in, edgeIn), (out, edgeOut)) => out <> in - // Does the request overlap the pattern ? - val abase = in.a.bits.address - val amask = UIntToOH1(in.a.bits.size, log2Up(edgeIn.maxTransfer)) - val overlaps = pattern.map { case a => - val pbase = UInt(a.base) - val pmask = UInt(a.mask & ((BigInt(1) << edgeIn.bundle.addressBits) - 1)) - (amask | pmask | ~(abase ^ pbase)).andR - }.reduce(_ || _) + // Should the request receive an error ? + val inject_map = Mem(edgeIn.client.endSourceId, Bool()) + val inject_now = test(in.a.bits) val (d_first, d_last, _) = edgeOut.firstlast(out.d) - val inject = Mem(edgeIn.client.endSourceId, Bool()) - when (in.a.fire()) { inject.write(in.a.bits.source, overlaps) } + when (in.a.fire()) { inject_map.write(in.a.bits.source, inject_now) } val bypass = in.a.fire() && in.a.bits.source === in.d.bits.source - val d_inject = Mux(bypass, overlaps, inject.read(in.d.bits.source)) holdUnless d_first + val d_inject = Mux(bypass, inject_now, inject_map.read(in.d.bits.source)) holdUnless d_first in.d.bits.error := out.d.bits.error || (d_last && d_inject) assert (Bool(!testOn) || !out.d.fire() || !d_last || !d_inject || out.d.bits.error, "Error flag was not set!") @@ -45,6 +61,6 @@ class TLErrorEvaluator(pattern: Seq[AddressSet], testOn: Boolean, testOff: Boole object TLErrorEvaluator { - def apply(pattern: Seq[AddressSet], testOn: Boolean = false, testOff: Boolean = false)(implicit p: Parameters): TLNode = - LazyModule(new TLErrorEvaluator(pattern, testOn, testOff)).node + def apply(test: RequestPattern, testOn: Boolean = false, testOff: Boolean = false)(implicit p: Parameters): TLNode = + LazyModule(new TLErrorEvaluator(test, testOn, testOff)).node }