2 files changed, 92 insertions, 13 deletions

diff --git a/src/mem/cache/tags/sector_blk.cc b/src/mem/cache/tags/sector_blk.cc
index de9153639..93b1961d8 100644
--- a/src/mem/cache/tags/sector_blk.cc
+++ b/src/mem/cache/tags/sector_blk.cc
@@ -72,6 +72,27 @@ SectorSubBlk::getTag() const
 }
 
 void
+SectorSubBlk::setValid()
+{
+    CacheBlk::setValid();
+    _sectorBlk->validateSubBlk();
+}
+
+void
+SectorSubBlk::setSecure()
+{
+    CacheBlk::setSecure();
+    _sectorBlk->setSecure();
+}
+
+void
+SectorSubBlk::invalidate()
+{
+    CacheBlk::invalidate();
+    _sectorBlk->invalidateSubBlk();
+}
+
+void
 SectorSubBlk::insert(const Addr tag, const bool is_secure,
                      const int src_master_ID, const uint32_t task_ID)
 {
@@ -94,28 +115,23 @@ SectorSubBlk::print() const
                     getSectorOffset());
 }
 
+SectorBlk::SectorBlk()
+    : ReplaceableEntry(), _tag(MaxAddr), _validCounter(0), _secureBit(false)
+{
+}
+
 bool
 SectorBlk::isValid() const
 {
     // If any of the blocks in the sector is valid, so is the sector
-    for (const auto& blk : blks) {
-        if (blk->isValid()) {
-            return true;
-        }
-    }
-    return false;
+    return _validCounter > 0;
 }
 
 bool
 SectorBlk::isSecure() const
 {
     // If any of the valid blocks in the sector is secure, so is the sector
-    for (const auto& blk : blks) {
-        if (blk->isValid()) {
-            return blk->isSecure();
-        }
-    }
-    return false;
+    return _secureBit;
 }
 
 void
@@ -129,3 +145,25 @@ SectorBlk::getTag() const
 {
     return _tag;
 }
+
+void
+SectorBlk::validateSubBlk()
+{
+    _validCounter++;
+}
+
+void
+SectorBlk::invalidateSubBlk()
+{
+    // If all sub-blocks have been invalidated, the sector becomes invalid,
+    // so clear secure bit
+    if (--_validCounter == 0) {
+        _secureBit = false;
+    }
+}
+
+void
+SectorBlk::setSecure()
+{
+    _secureBit = true;
+}
diff --git a/src/mem/cache/tags/sector_blk.hh b/src/mem/cache/tags/sector_blk.hh
index 12649fce2..264836ca2 100644
--- a/src/mem/cache/tags/sector_blk.hh
+++ b/src/mem/cache/tags/sector_blk.hh
@@ -102,6 +102,21 @@ class SectorSubBlk : public CacheBlk
     Addr getTag() const;
 
     /**
+     * Set valid bit and inform sector block.
+     */
+    void setValid() override;
+
+    /**
+     * Set secure bit and inform sector block.
+     */
+    void setSecure() override;
+
+    /**
+     * Invalidate the block and inform sector block.
+     */
+    void invalidate() override;
+
+    /**
      * Set member variables when a block insertion occurs. Resets reference
      * count to 1 (the insertion counts as a reference), and touch block if
      * it hadn't been touched previously. Sets the insertion tick to the
@@ -135,8 +150,19 @@ class SectorBlk : public ReplaceableEntry
      */
     Addr _tag;
 
+    /**
+     * Counter of the number of valid sub-blocks. The sector is valid if any
+     * of its sub-blocks is valid.
+     */
+    uint8_t _validCounter;
+
+    /**
+     * Whether sector blk is in secure-space or not.
+     */
+    bool _secureBit;
+
   public:
-    SectorBlk() : ReplaceableEntry(), _tag(MaxAddr) {}
+    SectorBlk();
     SectorBlk(const SectorBlk&) = delete;
     SectorBlk& operator=(const SectorBlk&) = delete;
     ~SectorBlk() {};
@@ -173,6 +199,21 @@ class SectorBlk : public ReplaceableEntry
      * @return The tag value.
      */
     Addr getTag() const;
+
+    /**
+     * Increase the number of valid sub-blocks.
+     */
+    void validateSubBlk();
+
+    /**
+     * Decrease the number of valid sub-blocks.
+     */
+    void invalidateSubBlk();
+
+    /**
+     * Set secure bit.
+     */
+    void setSecure();
 };
 
 #endif //__MEM_CACHE_TAGS_SECTOR_BLK_HH__