Merge pull request #3572 from chipsalliance/tl-sorted

Use sortedSlaves in some TL helpers

src/main/scala/tilelink/Parameters.scala

@@ -177,6 +177,7 @@ class TLSlaveParameters private(
                                    // ReleaseAck may NEVER be denied
   extends SimpleProduct
 {
+  def sortedAddress = address.sorted
   override def canEqual(that: Any): Boolean = that.isInstanceOf[TLSlaveParameters]
   override def productPrefix = "TLSlaveParameters"
   // We intentionally omit nodePath for equality testing / formatting
@@ -516,6 +517,7 @@ class TLSlavePortParameters private(
   val responseFields: Seq[BundleFieldBase],
   val requestKeys:    Seq[BundleKeyBase]) extends SimpleProduct
 {
+  def sortedSlaves = slaves.sortBy(_.sortedAddress.head)
   override def canEqual(that: Any): Boolean = that.isInstanceOf[TLSlavePortParameters]
   override def productPrefix = "TLSlavePortParameters"
   def productArity: Int = 6
@@ -596,16 +598,16 @@ class TLSlavePortParameters private(
   def find(address: BigInt) = slaves.find(_.address.exists(_.contains(address)))
 
   // The safe version will check the entire address
-  def findSafe(address: UInt) = VecInit(slaves.map(_.address.map(_.contains(address)).reduce(_ || _)))
+  def findSafe(address: UInt) = VecInit(sortedSlaves.map(_.address.map(_.contains(address)).reduce(_ || _)))
   // The fast version assumes the address is valid (you probably want fastProperty instead of this function)
   def findFast(address: UInt) = {
     val routingMask = AddressDecoder(slaves.map(_.address))
-    VecInit(slaves.map(_.address.map(_.widen(~routingMask)).distinct.map(_.contains(address)).reduce(_ || _)))
+    VecInit(sortedSlaves.map(_.address.map(_.widen(~routingMask)).distinct.map(_.contains(address)).reduce(_ || _)))
   }
 
   // Compute the simplest AddressSets that decide a key
   def fastPropertyGroup[K](p: TLSlaveParameters => K): Seq[(K, Seq[AddressSet])] = {
-    val groups = groupByIntoSeq(slaves.map(m => (p(m), m.address)))( _._1).map { case (k, vs) =>
+    val groups = groupByIntoSeq(sortedSlaves.map(m => (p(m), m.address)))( _._1).map { case (k, vs) =>
       k -> vs.flatMap(_._2)
     }
     val reductionMask = AddressDecoder(groups.map(_._2))