diff --git a/src/mem/ruby/slicc_interface/Message.hh b/src/mem/ruby/slicc_interface/Message.hh
--- a/src/mem/ruby/slicc_interface/Message.hh
+++ b/src/mem/ruby/slicc_interface/Message.hh
@@ -73,8 +73,10 @@
      * class that can be potentially searched for the address needs to
      * implement these methods.
      */
-    virtual bool functionalRead(Packet *pkt) = 0;
-    virtual bool functionalWrite(Packet *pkt) = 0;
+    virtual bool functionalRead(Packet *pkt,
+                                const uint32_t &block_size_bits) = 0;
+    virtual bool functionalWrite(Packet *pkt,
+                                 const uint32_t &block_size_bits) = 0;
 
     //! Update the delay this message has experienced so far.
     void updateDelayedTicks(Tick curTime)
diff --git a/src/mem/ruby/slicc_interface/RubyRequest.hh b/src/mem/ruby/slicc_interface/RubyRequest.hh
--- a/src/mem/ruby/slicc_interface/RubyRequest.hh
+++ b/src/mem/ruby/slicc_interface/RubyRequest.hh
@@ -152,8 +152,8 @@
     const PrefetchBit& getPrefetch() const { return m_Prefetch; }
 
     void print(std::ostream& out) const;
-    bool functionalRead(Packet *pkt);
-    bool functionalWrite(Packet *pkt);
+    bool functionalRead(Packet *pkt, const uint32_t &block_size_bits);
+    bool functionalWrite(Packet *pkt, const uint32_t &block_size_bits);
 };
 
 inline std::ostream&
diff --git a/src/mem/ruby/slicc_interface/RubyRequest.cc b/src/mem/ruby/slicc_interface/RubyRequest.cc
--- a/src/mem/ruby/slicc_interface/RubyRequest.cc
+++ b/src/mem/ruby/slicc_interface/RubyRequest.cc
@@ -48,7 +48,7 @@
 }
 
 bool
-RubyRequest::functionalRead(Packet *pkt)
+RubyRequest::functionalRead(Packet *pkt, const uint32_t &block_size_bits)
 {
     // This needs a little explanation. Initially I thought that this
     // message should be read. But the way the memtester works for now,
@@ -58,7 +58,7 @@
 }
 
 bool
-RubyRequest::functionalWrite(Packet *pkt)
+RubyRequest::functionalWrite(Packet *pkt, const uint32_t &block_size_bits)
 {
     // This needs a little explanation. I am not sure if this message
     // should be written. Essentially the question is how are writes
diff --git a/src/mem/ruby/system/RubySystem.cc b/src/mem/ruby/system/RubySystem.cc
--- a/src/mem/ruby/system/RubySystem.cc
+++ b/src/mem/ruby/system/RubySystem.cc
@@ -502,7 +502,8 @@
         }
     }
 
-    num_functional_writes += m_network->functionalWrite(pkt);
+    num_functional_writes += m_network->functionalWrite(pkt,
+                                                        m_block_size_bits);
     DPRINTF(RubySystem, "Messages written = %u\n", num_functional_writes);
 
     return true;
diff --git a/src/mem/slicc/symbols/StateMachine.py b/src/mem/slicc/symbols/StateMachine.py
--- a/src/mem/slicc/symbols/StateMachine.py
+++ b/src/mem/slicc/symbols/StateMachine.py
@@ -1006,17 +1006,13 @@
 {
     int num_functional_writes = 0;
 ''')
-        for var in self.objects:
-            vtype = var.type
-            if vtype.isBuffer:
-                vid = "m_%s" % var.ident
-                code('num_functional_writes += $vid->functionalWrite(pkt);')
-
         for var in self.config_parameters:
             vtype = var.type_ast.type
             if vtype.isBuffer:
                 vid = "m_%s" % var.ident
-                code('num_functional_writes += $vid->functionalWrite(pkt);')
+                code('''
+num_functional_writes += $vid->functionalWrite(pkt, m_block_size_bits);
+''')
 
         code('''
     return num_functional_writes;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.hh b/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.hh
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.hh
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.hh
@@ -52,8 +52,8 @@
     void insert(flit *flt);
     void print(std::ostream& out) const;
 
-    bool functionalRead(Packet *);
-    uint32_t functionalWrite(Packet *);
+    bool functionalRead(Packet *, uint32_t block_size_bits);
+    uint32_t functionalWrite(Packet *, uint32_t block_size_bits);
 
   private:
     std::vector<flit *> m_buffer;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc b/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flitBuffer.cc
@@ -103,10 +103,10 @@
 }
 
 bool
-flitBuffer::functionalRead(Packet *pkt)
+flitBuffer::functionalRead(Packet *pkt, uint32_t block_size_bits)
 {
     for (unsigned int i = 0; i < m_buffer.size(); ++i) {
-        if (m_buffer[i]->functionalRead(pkt)) {
+        if (m_buffer[i]->functionalRead(pkt, block_size_bits)) {
             return true;
         }
     }
@@ -114,12 +114,12 @@
 }
 
 uint32_t
-flitBuffer::functionalWrite(Packet *pkt)
+flitBuffer::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
 
     for (unsigned int i = 0; i < m_buffer.size(); ++i) {
-        if (m_buffer[i]->functionalWrite(pkt)) {
+        if (m_buffer[i]->functionalWrite(pkt, block_size_bits)) {
             num_functional_writes++;
         }
     }
diff --git a/src/mem/ruby/network/simple/SimpleNetwork.hh b/src/mem/ruby/network/simple/SimpleNetwork.hh
--- a/src/mem/ruby/network/simple/SimpleNetwork.hh
+++ b/src/mem/ruby/network/simple/SimpleNetwork.hh
@@ -71,8 +71,8 @@
 
     void print(std::ostream& out) const;
 
-    bool functionalRead(Packet *pkt);
-    uint32_t functionalWrite(Packet *pkt);
+    bool functionalRead(Packet *pkt, uint32_t block_size_bits);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     void addLink(SwitchID src, SwitchID dest, int link_latency);
diff --git a/src/mem/ruby/network/simple/SimpleNetwork.cc b/src/mem/ruby/network/simple/SimpleNetwork.cc
--- a/src/mem/ruby/network/simple/SimpleNetwork.cc
+++ b/src/mem/ruby/network/simple/SimpleNetwork.cc
@@ -181,10 +181,10 @@
  * between different switches have buffers that need to be accessed.
  */
 bool
-SimpleNetwork::functionalRead(Packet *pkt)
+SimpleNetwork::functionalRead(Packet *pkt, uint32_t block_size_bits)
 {
     for (unsigned int i = 0; i < m_switches.size(); i++) {
-        if (m_switches[i]->functionalRead(pkt)) {
+        if (m_switches[i]->functionalRead(pkt, block_size_bits)) {
             return true;
         }
     }
@@ -193,16 +193,18 @@
 }
 
 uint32_t
-SimpleNetwork::functionalWrite(Packet *pkt)
+SimpleNetwork::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
 
     for (unsigned int i = 0; i < m_switches.size(); i++) {
-        num_functional_writes += m_switches[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_switches[i]->functionalWrite(pkt, block_size_bits);
     }
 
     for (unsigned int i = 0; i < m_int_link_buffers.size(); ++i) {
-        num_functional_writes += m_int_link_buffers[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_int_link_buffers[i]->functionalWrite(pkt, block_size_bits);
     }
     return num_functional_writes;
 }
diff --git a/src/mem/ruby/network/simple/Switch.hh b/src/mem/ruby/network/simple/Switch.hh
--- a/src/mem/ruby/network/simple/Switch.hh
+++ b/src/mem/ruby/network/simple/Switch.hh
@@ -78,8 +78,8 @@
     void print(std::ostream& out) const;
     void init_net_ptr(SimpleNetwork* net_ptr) { m_network_ptr = net_ptr; }
 
-    bool functionalRead(Packet *);
-    uint32_t functionalWrite(Packet *);
+    bool functionalRead(Packet *pkt, uint32_t block_size_bits);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     // Private copy constructor and assignment operator
diff --git a/src/mem/ruby/network/simple/Switch.cc b/src/mem/ruby/network/simple/Switch.cc
--- a/src/mem/ruby/network/simple/Switch.cc
+++ b/src/mem/ruby/network/simple/Switch.cc
@@ -169,18 +169,19 @@
 }
 
 bool
-Switch::functionalRead(Packet *pkt)
+Switch::functionalRead(Packet *pkt, uint32_t block_size_bits)
 {
     return false;
 }
 
 uint32_t
-Switch::functionalWrite(Packet *pkt)
+Switch::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     // Access the buffers in the switch for performing a functional write
     uint32_t num_functional_writes = 0;
     for (unsigned int i = 0; i < m_port_buffers.size(); ++i) {
-        num_functional_writes += m_port_buffers[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_port_buffers[i]->functionalWrite(pkt, block_size_bits);
     }
     return num_functional_writes;
 }
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/flit_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/flit_d.cc
--- a/src/mem/ruby/network/garnet/fixed-pipeline/flit_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/flit_d.cc
@@ -76,8 +76,8 @@
 }
 
 bool
-flit_d::functionalWrite(Packet *pkt)
+flit_d::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     Message *msg = m_msg_ptr.get();
-    return msg->functionalWrite(pkt);
+    return msg->functionalWrite(pkt, block_size_bits);
 }
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.hh b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.hh
--- a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.hh
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.hh
@@ -72,11 +72,11 @@
 
     //! Function for performing a functional read. The return value
     //! indicates if a message was found that had the required address.
-    bool functionalRead(Packet *pkt);
+    bool functionalRead(Packet *pkt, uint32_t block_size_bits);
 
     //! Function for performing a functional write. The return value
     //! indicates the number of messages that were written.
-    uint32_t functionalWrite(Packet *pkt);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     GarnetNetwork(const GarnetNetwork& obj);
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc
--- a/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/GarnetNetwork.cc
@@ -148,22 +148,22 @@
  * links for reading/writing all the messages.
  */
 bool
-GarnetNetwork::functionalRead(Packet *pkt)
+GarnetNetwork::functionalRead(Packet *pkt, uint32_t block_size_bits)
 {
     for (unsigned int i = 0; i < m_routers.size(); i++) {
-        if (m_routers[i]->functionalRead(pkt)) {
+        if (m_routers[i]->functionalRead(pkt, block_size_bits)) {
             return true;
         }
     }
 
     for (unsigned int i = 0; i < m_nis.size(); ++i) {
-        if (m_nis[i]->functionalRead(pkt)) {
+        if (m_nis[i]->functionalRead(pkt, block_size_bits)) {
             return true;
         }
     }
 
     for (unsigned int i = 0; i < m_links.size(); ++i) {
-        if (m_links[i]->functionalRead(pkt)) {
+        if (m_links[i]->functionalRead(pkt, block_size_bits)) {
             return true;
         }
     }
@@ -172,20 +172,23 @@
 }
 
 uint32_t
-GarnetNetwork::functionalWrite(Packet *pkt)
+GarnetNetwork::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
 
     for (unsigned int i = 0; i < m_routers.size(); i++) {
-        num_functional_writes += m_routers[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_routers[i]->functionalWrite(pkt, block_size_bits);
     }
 
     for (unsigned int i = 0; i < m_nis.size(); ++i) {
-        num_functional_writes += m_nis[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_nis[i]->functionalWrite(pkt, block_size_bits);
     }
 
     for (unsigned int i = 0; i < m_links.size(); ++i) {
-        num_functional_writes += m_links[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_links[i]->functionalWrite(pkt, block_size_bits);
     }
 
     return num_functional_writes;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.hh b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.hh
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.hh
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.hh
@@ -68,8 +68,8 @@
 
     void print(std::ostream& out) const;
 
-    bool functionalRead(Packet *);
-    uint32_t functionalWrite(Packet *);
+    bool functionalRead(Packet *pkt, uint32_t block_size_bits);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
     void init_net_ptr(GarnetNetwork* net_ptr) { m_net_ptr = net_ptr; }
 
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkInterface.cc
@@ -342,17 +342,17 @@
 }
 
 bool
-NetworkInterface::functionalRead(Packet *pkt)
+NetworkInterface::functionalRead(Packet *pkt, uint32_t block_size_bits)
 {
     // Go through the internal buffers
     for (unsigned int i = 0; i < m_ni_buffers.size(); ++i) {
-        if (m_ni_buffers[i]->functionalRead(pkt)) {
+        if (m_ni_buffers[i]->functionalRead(pkt, block_size_bits)) {
             return true;
         }
     }
 
     // Go through the buffer between this network interface and the router
-    if (outSrcQueue->functionalRead(pkt)) {
+    if (outSrcQueue->functionalRead(pkt, block_size_bits)) {
         return true;
     }
 
@@ -360,14 +360,16 @@
 }
 
 uint32_t
-NetworkInterface::functionalWrite(Packet *pkt)
+NetworkInterface::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
     for (unsigned int i = 0; i < m_ni_buffers.size(); ++i) {
-        num_functional_writes += m_ni_buffers[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_ni_buffers[i]->functionalWrite(pkt, block_size_bits);
     }
 
-    num_functional_writes += outSrcQueue->functionalWrite(pkt);
+    num_functional_writes +=
+        outSrcQueue->functionalWrite(pkt, block_size_bits);
     return num_functional_writes;
 }
 
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.hh b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.hh
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.hh
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.hh
@@ -74,8 +74,8 @@
     unsigned int getLinkUtilization() const { return m_link_utilized; }
     const std::vector<unsigned int> & getVcLoad() const { return m_vc_load; }
 
-    bool functionalRead(Packet *);
-    uint32_t functionalWrite(Packet *);
+    bool functionalRead(Packet *pkt, uint32_t block_size_bits);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     int m_id;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.cc b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.cc
--- a/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/NetworkLink.cc
@@ -133,15 +133,15 @@
 }
 
 bool
-NetworkLink::functionalRead(Packet *pkt)
+NetworkLink::functionalRead(Packet *pkt, uint32_t block_size_bits)
 {
-    return linkBuffer->functionalRead(pkt);
+    return linkBuffer->functionalRead(pkt, block_size_bits);
 }
 
 uint32_t
-NetworkLink::functionalWrite(Packet *pkt)
+NetworkLink::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
-    return linkBuffer->functionalWrite(pkt);
+    return linkBuffer->functionalWrite(pkt, block_size_bits);
 }
 
 NetworkLink *
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/Router.hh b/src/mem/ruby/network/garnet/flexible-pipeline/Router.hh
--- a/src/mem/ruby/network/garnet/flexible-pipeline/Router.hh
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/Router.hh
@@ -73,8 +73,8 @@
         m_net_ptr = net_ptr;
     }
 
-    bool functionalRead(Packet *);
-    uint32_t functionalWrite(Packet *);
+    bool functionalRead(Packet *pkt, uint32_t block_size_bits);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     int m_virtual_networks, m_num_vcs, m_vc_per_vnet;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc b/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
--- a/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/Router.cc
@@ -394,12 +394,13 @@
 }
 
 bool
-Router::functionalRead(Packet *pkt)
+Router::functionalRead(Packet *pkt, uint32_t block_size_bits)
 {
     // Access the buffers in the router for performing a functional read
     for (unsigned int i = 0; i < m_router_buffers.size(); i++) {
         for (unsigned int j = 0; j < m_router_buffers[i].size(); ++j) {
-            if (m_router_buffers[i][j]->functionalRead(pkt)) {
+            if (m_router_buffers[i][j]->functionalRead(pkt,
+                                                       block_size_bits)) {
                 return true;
             }
         }
@@ -407,7 +408,7 @@
 
     // Access the link queues for performing a functional read
     for (unsigned int i = 0; i < m_out_src_queue.size(); i++) {
-        if (m_out_src_queue[i]->functionalRead(pkt)) {
+        if (m_out_src_queue[i]->functionalRead(pkt, block_size_bits)) {
             return true;
         }
     }
@@ -415,7 +416,7 @@
 }
 
 uint32_t
-Router::functionalWrite(Packet *pkt)
+Router::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
 
@@ -423,13 +424,15 @@
     for (unsigned int i = 0; i < m_router_buffers.size(); i++) {
         for (unsigned int j = 0; j < m_router_buffers[i].size(); ++j) {
             num_functional_writes +=
-                m_router_buffers[i][j]->functionalWrite(pkt);
+                m_router_buffers[i][j]->functionalWrite(pkt,
+                                                        block_size_bits);
         }
     }
 
     // Access the link queues for performing a functional write
     for (unsigned int i = 0; i < m_out_src_queue.size(); i++) {
-        num_functional_writes += m_out_src_queue[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_out_src_queue[i]->functionalWrite(pkt, block_size_bits);
     }
 
     return num_functional_writes;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh b/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flit.hh
@@ -67,8 +67,8 @@
             return (n1->get_time() > n2->get_time());
     }
 
-    bool functionalRead(Packet *pkt);
-    bool functionalWrite(Packet *pkt);
+    bool functionalRead(Packet *pkt, uint32_t block_size_bits);
+    bool functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     const int m_id;
diff --git a/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc b/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
--- a/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
+++ b/src/mem/ruby/network/garnet/flexible-pipeline/flit.cc
@@ -61,15 +61,15 @@
 }
 
 bool
-flit::functionalRead(Packet *pkt)
+flit::functionalRead(Packet *pkt, uint32_t block_size_bits)
 {
     Message *msg = m_msg_ptr.get();
-    return msg->functionalRead(pkt);
+    return msg->functionalRead(pkt, block_size_bits);
 }
 
 bool
-flit::functionalWrite(Packet *pkt)
+flit::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     Message *msg = m_msg_ptr.get();
-    return msg->functionalWrite(pkt);
+    return msg->functionalWrite(pkt, block_size_bits);
 }
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/VirtualChannel_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/VirtualChannel_d.hh
--- a/src/mem/ruby/network/garnet/fixed-pipeline/VirtualChannel_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/VirtualChannel_d.hh
@@ -85,7 +85,7 @@
         return m_input_buffer->getTopFlit();
     }
 
-    uint32_t functionalWrite(Packet *pkt);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     int m_id;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/VirtualChannel_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/VirtualChannel_d.cc
--- a/src/mem/ruby/network/garnet/fixed-pipeline/VirtualChannel_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/VirtualChannel_d.cc
@@ -74,7 +74,7 @@
 }
 
 uint32_t
-VirtualChannel_d::functionalWrite(Packet *pkt)
+VirtualChannel_d::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
-    return m_input_buffer->functionalWrite(pkt);
+    return m_input_buffer->functionalWrite(pkt, block_size_bits);
 }
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/flitBuffer_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/flitBuffer_d.hh
--- a/src/mem/ruby/network/garnet/fixed-pipeline/flitBuffer_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/flitBuffer_d.hh
@@ -72,7 +72,7 @@
         std::push_heap(m_buffer.begin(), m_buffer.end(), flit_d::greater);
     }
 
-    uint32_t functionalWrite(Packet *pkt);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     std::vector<flit_d *> m_buffer;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/flitBuffer_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/flitBuffer_d.cc
--- a/src/mem/ruby/network/garnet/fixed-pipeline/flitBuffer_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/flitBuffer_d.cc
@@ -76,12 +76,12 @@
 }
 
 uint32_t
-flitBuffer_d::functionalWrite(Packet *pkt)
+flitBuffer_d::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
 
     for (unsigned int i = 0; i < m_buffer.size(); ++i) {
-        if (m_buffer[i]->functionalWrite(pkt)) {
+        if (m_buffer[i]->functionalWrite(pkt, block_size_bits)) {
             num_functional_writes++;
         }
     }
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/flit_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/flit_d.hh
--- a/src/mem/ruby/network/garnet/fixed-pipeline/flit_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/flit_d.hh
@@ -88,7 +88,7 @@
         }
     }
 
-    bool functionalWrite(Packet *pkt);
+    bool functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     int m_id;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/OutputUnit_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/OutputUnit_d.cc
--- a/src/mem/ruby/network/garnet/fixed-pipeline/OutputUnit_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/OutputUnit_d.cc
@@ -110,7 +110,7 @@
 }
 
 uint32_t
-OutputUnit_d::functionalWrite(Packet *pkt)
+OutputUnit_d::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
-    return m_out_buffer->functionalWrite(pkt);
+    return m_out_buffer->functionalWrite(pkt, block_size_bits);
 }
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/Router_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/Router_d.hh
--- a/src/mem/ruby/network/garnet/fixed-pipeline/Router_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/Router_d.hh
@@ -105,7 +105,7 @@
                                                       aggregate_fault_prob);
     }
 
-    uint32_t functionalWrite(Packet *);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     int m_virtual_networks, m_num_vcs, m_vc_per_vnet;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/Router_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/Router_d.cc
--- a/src/mem/ruby/network/garnet/fixed-pipeline/Router_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/Router_d.cc
@@ -252,17 +252,19 @@
 }
 
 uint32_t
-Router_d::functionalWrite(Packet *pkt)
+Router_d::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
-    num_functional_writes += m_switch->functionalWrite(pkt);
+    num_functional_writes += m_switch->functionalWrite(pkt, block_size_bits);
 
     for (uint32_t i = 0; i < m_input_unit.size(); i++) {
-        num_functional_writes += m_input_unit[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_input_unit[i]->functionalWrite(pkt, block_size_bits);
     }
 
     for (uint32_t i = 0; i < m_output_unit.size(); i++) {
-        num_functional_writes += m_output_unit[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_output_unit[i]->functionalWrite(pkt, block_size_bits);
     }
 
     return num_functional_writes;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/Switch_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/Switch_d.hh
--- a/src/mem/ruby/network/garnet/fixed-pipeline/Switch_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/Switch_d.hh
@@ -56,7 +56,7 @@
 
     inline double get_crossbar_count() { return m_crossbar_activity; }
 
-    uint32_t functionalWrite(Packet *pkt);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     int m_num_vcs;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/Switch_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/Switch_d.cc
--- a/src/mem/ruby/network/garnet/fixed-pipeline/Switch_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/Switch_d.cc
@@ -99,12 +99,13 @@
 }
 
 uint32_t
-Switch_d::functionalWrite(Packet *pkt)
+Switch_d::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
    uint32_t num_functional_writes = 0;
 
    for (uint32_t i = 0; i < m_switch_buffer.size(); ++i) {
-       num_functional_writes += m_switch_buffer[i]->functionalWrite(pkt);
+       num_functional_writes +=
+           m_switch_buffer[i]->functionalWrite(pkt, block_size_bits);
    }
 
    return num_functional_writes;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.hh
--- a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.hh
@@ -66,7 +66,7 @@
     int get_vnet(int vc);
     void init_net_ptr(GarnetNetwork_d *net_ptr) { m_net_ptr = net_ptr; }
 
-    uint32_t functionalWrite(Packet *);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     GarnetNetwork_d *m_net_ptr;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc
--- a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkInterface_d.cc
@@ -376,14 +376,16 @@
 }
 
 uint32_t
-NetworkInterface_d::functionalWrite(Packet *pkt)
+NetworkInterface_d::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
     for (unsigned int i  = 0; i < m_num_vcs; ++i) {
-        num_functional_writes += m_ni_buffers[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_ni_buffers[i]->functionalWrite(pkt, block_size_bits);
     }
 
-    num_functional_writes += outSrcQueue->functionalWrite(pkt);
+    num_functional_writes += outSrcQueue->functionalWrite(pkt,
+                                                          block_size_bits);
     return num_functional_writes;
 }
 
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkLink_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkLink_d.hh
--- a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkLink_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkLink_d.hh
@@ -64,7 +64,7 @@
     inline flit_d* peekLink()       { return linkBuffer->peekTopFlit(); }
     inline flit_d* consumeLink()    { return linkBuffer->getTopFlit(); }
 
-    uint32_t functionalWrite(Packet *);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     const int m_id;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkLink_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkLink_d.cc
--- a/src/mem/ruby/network/garnet/fixed-pipeline/NetworkLink_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/NetworkLink_d.cc
@@ -83,7 +83,7 @@
 }
 
 uint32_t
-NetworkLink_d::functionalWrite(Packet *pkt)
+NetworkLink_d::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
-    return linkBuffer->functionalWrite(pkt);
+    return linkBuffer->functionalWrite(pkt, block_size_bits);
 }
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/OutputUnit_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/OutputUnit_d.hh
--- a/src/mem/ruby/network/garnet/fixed-pipeline/OutputUnit_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/OutputUnit_d.hh
@@ -86,7 +86,7 @@
         m_out_link->scheduleEventAbsolute(m_router->clockEdge(Cycles(1)));
     }
 
-    uint32_t functionalWrite(Packet *pkt);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     int m_id;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/InputUnit_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/InputUnit_d.cc
--- a/src/mem/ruby/network/garnet/fixed-pipeline/InputUnit_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/InputUnit_d.cc
@@ -102,11 +102,12 @@
 }
 
 uint32_t
-InputUnit_d::functionalWrite(Packet *pkt)
+InputUnit_d::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
     for (int i=0; i < m_num_vcs; i++) {
-        num_functional_writes += m_vcs[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_vcs[i]->functionalWrite(pkt, block_size_bits);
     }
 
     return num_functional_writes;
# Node ID 6901103f7f04d788302cc64e62667c080420858c
# Parent  41c966b4e307e574e660b33e7987a61bb5beb78c
diff --git a/src/mem/protocol/MESI_Three_Level-msg.sm b/src/mem/protocol/MESI_Three_Level-msg.sm
--- a/src/mem/protocol/MESI_Three_Level-msg.sm
+++ b/src/mem/protocol/MESI_Three_Level-msg.sm
@@ -59,7 +59,7 @@
   DataBlock DataBlk,            desc="Data for the cache line (if PUTX)";
   bool Dirty, default="false",  desc="Dirty bit";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Only PUTX messages contains the data block
     if (Class == CoherenceClass:PUTX) {
         return testAndRead(addr, DataBlk, pkt);
@@ -68,7 +68,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return testAndWrite(addr, DataBlk, pkt);
diff --git a/src/mem/protocol/MESI_Two_Level-msg.sm b/src/mem/protocol/MESI_Two_Level-msg.sm
--- a/src/mem/protocol/MESI_Two_Level-msg.sm
+++ b/src/mem/protocol/MESI_Two_Level-msg.sm
@@ -69,7 +69,7 @@
   bool Dirty, default="false",  desc="Dirty bit";
   PrefetchBit Prefetch,         desc="Is this a prefetch request";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Only PUTX messages contains the data block
     if (Type == CoherenceRequestType:PUTX) {
         return testAndRead(addr, DataBlk, pkt);
@@ -78,7 +78,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return testAndWrite(addr, DataBlk, pkt);
@@ -96,7 +96,7 @@
   int AckCount, default="0",  desc="number of acks in this message";
   MessageSizeType MessageSize,  desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Valid data block is only present in message with following types
     if (Type == CoherenceResponseType:DATA ||
         Type == CoherenceResponseType:DATA_EXCLUSIVE ||
@@ -108,7 +108,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return testAndWrite(addr, DataBlk, pkt);
diff --git a/src/mem/protocol/MI_example-msg.sm b/src/mem/protocol/MI_example-msg.sm
--- a/src/mem/protocol/MI_example-msg.sm
+++ b/src/mem/protocol/MI_example-msg.sm
@@ -58,7 +58,7 @@
   DataBlock DataBlk,           desc="data for the cache line";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Valid data block is only present in PUTX messages
     if (Type == CoherenceRequestType:PUTX) {
         return testAndRead(addr, DataBlk, pkt);
@@ -66,7 +66,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should read
     // data block from only those messages that contain valid data
     return testAndWrite(addr, DataBlk, pkt);
@@ -83,13 +83,13 @@
   bool Dirty,                  desc="Is the data dirty (different than memory)?";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // A check on message type should appear here so that only those
     // messages that contain data
     return testAndRead(addr, DataBlk, pkt);
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should read
     // data block from only those messages that contain valid data
     return testAndWrite(addr, DataBlk, pkt);
@@ -118,11 +118,11 @@
   int Len,                   desc="The length of the request";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return testAndRead(LineAddress, DataBlk, pkt);
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     return testAndWrite(LineAddress, DataBlk, pkt);
   }
 }
@@ -135,11 +135,11 @@
   DataBlock DataBlk,         desc="DataBlk attached to this request";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return testAndRead(LineAddress, DataBlk, pkt);
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     return testAndWrite(LineAddress, DataBlk, pkt);
   }
 }
diff --git a/src/mem/protocol/MOESI_AMD_Base-Region-msg.sm b/src/mem/protocol/MOESI_AMD_Base-Region-msg.sm
--- a/src/mem/protocol/MOESI_AMD_Base-Region-msg.sm
+++ b/src/mem/protocol/MOESI_AMD_Base-Region-msg.sm
@@ -127,7 +127,7 @@
   int Acks, default="0", desc="Acks that the dir (mem ctrl) should expect to receive";
   CoherenceRequestType OriginalType, default="CoherenceRequestType_NA",  desc="Type of request from core fwded through region buffer";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Only PUTX messages contains the data block
     if (Type == CoherenceRequestType:VicDirty) {
         return testAndRead(addr, DataBlk, pkt);
@@ -136,7 +136,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return testAndWrite(addr, DataBlk, pkt);
@@ -154,11 +154,11 @@
   MachineID Requestor,          desc="Requestor id for 3-hop requests";
   bool NoAckNeeded, default="false", desc="For short circuting acks";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return false;
@@ -181,11 +181,11 @@
   bool valid, default="false", desc="Is block valid";
   bool validToInvalid, default="false", desc="Was block valid when evicted";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return false;
@@ -228,7 +228,7 @@
   bool NoAckNeeded, default="false", desc="For short circuting acks";
   bool isValid, default="false", desc="Is acked block valid";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Only PUTX messages contains the data block
     if (Type == CoherenceResponseType:CPUData ||
         Type == CoherenceResponseType:MemData) {
@@ -238,7 +238,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return testAndWrite(addr, DataBlk, pkt);
@@ -278,11 +278,11 @@
   TriggerType Type,             desc="Type of trigger";
   CacheId Dest,         default="CacheId_NA", desc="Cache to invalidate";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return false;
diff --git a/src/mem/protocol/MOESI_AMD_Base-msg.sm b/src/mem/protocol/MOESI_AMD_Base-msg.sm
--- a/src/mem/protocol/MOESI_AMD_Base-msg.sm
+++ b/src/mem/protocol/MOESI_AMD_Base-msg.sm
@@ -142,7 +142,7 @@
   bool NoWriteConflict,             default="true", desc="write collided with CAB entry";
   int ProgramCounter,               desc="PC that accesses to this block";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Only PUTX messages contains the data block
     if (Type == CoherenceRequestType:VicDirty) {
         return testAndRead(addr, DataBlk, pkt);
@@ -151,7 +151,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return testAndWrite(addr, DataBlk, pkt);
@@ -170,11 +170,11 @@
   bool NoAckNeeded, default="false", desc="For short circuting acks";
   int ProgramCounter,           desc="PC that accesses to this block";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return false;
@@ -193,11 +193,11 @@
   int wfid,               desc="wavefront id for Release";
   MachineID Requestor,    desc="Node who initiated the request";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return false;
@@ -251,7 +251,7 @@
   bool mispred,              desc="tell TCP if the block should not be bypassed";
 
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Only PUTX messages contains the data block
     if (Type == CoherenceResponseType:CPUData ||
         Type == CoherenceResponseType:MemData) {
@@ -261,7 +261,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return testAndWrite(addr, DataBlk, pkt);
@@ -280,11 +280,11 @@
   bool valid, default="false", desc="Is block valid";
   bool validToInvalid, default="false", desc="Was block valid when evicted";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return false;
@@ -324,11 +324,11 @@
   CacheId Dest,         default="CacheId_NA", desc="Cache to invalidate";
   int ProgramCounter,           desc="PC that accesses to this block";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return false;
@@ -349,11 +349,11 @@
   MachineID Requestor,      desc="Flush Requestor";
   MachineID oRequestor,      desc="original Flush Requestor";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check on message type required since the protocol should
     // read data from those messages that contain the block
     return false;
diff --git a/src/mem/protocol/MOESI_CMP_directory-msg.sm b/src/mem/protocol/MOESI_CMP_directory-msg.sm
--- a/src/mem/protocol/MOESI_CMP_directory-msg.sm
+++ b/src/mem/protocol/MOESI_CMP_directory-msg.sm
@@ -72,12 +72,12 @@
   Addr addr,             desc="Physical address for this request";
   TriggerType Type,            desc="Type of trigger";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Trigger message does not hold data
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // Trigger message does not hold data
     return false;
   }
@@ -97,7 +97,7 @@
   RubyAccessMode AccessMode,    desc="user/supervisor access type";
   PrefetchBit Prefetch,         desc="Is this a prefetch request";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Read only those messages that contain the data
     if (Type == CoherenceRequestType:DMA_READ ||
         Type == CoherenceRequestType:DMA_WRITE) {
@@ -106,7 +106,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check required since all messages are written
     return testAndWrite(addr, DataBlk, pkt);
   }
@@ -124,7 +124,7 @@
   int Acks,                    desc="How many acks to expect";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Read only those messages that contain the data
     if (Type == CoherenceResponseType:DATA ||
         Type == CoherenceResponseType:DATA_EXCLUSIVE ||
@@ -135,7 +135,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check required since all messages are written
     return testAndWrite(addr, DataBlk, pkt);
   }
diff --git a/src/mem/protocol/MOESI_CMP_token-msg.sm b/src/mem/protocol/MOESI_CMP_token-msg.sm
--- a/src/mem/protocol/MOESI_CMP_token-msg.sm
+++ b/src/mem/protocol/MOESI_CMP_token-msg.sm
@@ -66,12 +66,12 @@
   RubyAccessMode AccessMode,    desc="user/supervisor access type";
   PrefetchBit Prefetch,         desc="Is this a prefetch request";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // No data in persistent messages
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No data in persistent messages
     return false;
   }
@@ -89,12 +89,12 @@
   RubyAccessMode AccessMode,    desc="user/supervisor access type";
   PrefetchBit Prefetch,         desc="Is this a prefetch request";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // No data in request messages
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No data in request messages
     return false;
   }
@@ -111,12 +111,12 @@
   bool Dirty,                  desc="Is the data dirty (different than memory)?";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // No check being carried out on the message type. Would be added later.
     return testAndRead(addr, DataBlk, pkt);
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // No check required since all messages are written.
     return testAndWrite(addr, DataBlk, pkt);
   }
@@ -144,11 +144,11 @@
   int Len,                   desc="The length of the request";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     return testAndWrite(LineAddress, DataBlk, pkt);
   }
 }
@@ -161,11 +161,11 @@
   DataBlock DataBlk,         desc="DataBlk attached to this request";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     return testAndWrite(LineAddress, DataBlk, pkt);
   }
 }
diff --git a/src/mem/protocol/MOESI_hammer-msg.sm b/src/mem/protocol/MOESI_hammer-msg.sm
--- a/src/mem/protocol/MOESI_hammer-msg.sm
+++ b/src/mem/protocol/MOESI_hammer-msg.sm
@@ -74,12 +74,12 @@
   Addr addr,             desc="Physical address for this request";
   TriggerType Type,            desc="Type of trigger";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Trigger messages do not hold any data!
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // Trigger messages do not hold any data!
     return false;
   }
@@ -101,12 +101,12 @@
         desc="time the dir forwarded the request";
   int SilentAcks, default="0", desc="silent acks from the full-bit directory";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // Request messages do not hold any data
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // Request messages do not hold any data
     return false;
   }
@@ -130,7 +130,7 @@
         desc="time the dir forwarded the request";
   int SilentAcks, default="0", desc="silent acks from the full-bit directory";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     // The check below ensures that data is read only from messages that
     // actually hold data.
     if (Type == CoherenceResponseType:DATA ||
@@ -144,7 +144,7 @@
     return false;
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     // Message type does not matter since all messages are written.
     // If a protocol reads data from a packet that is not supposed
     // to hold the data, then the fault lies with the protocol.
@@ -174,11 +174,11 @@
   int Len,                   desc="The length of the request";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return testAndRead(LineAddress, DataBlk, pkt);
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     return testAndWrite(LineAddress, DataBlk, pkt);
   }
 }
@@ -191,11 +191,11 @@
   DataBlock DataBlk,         desc="DataBlk attached to this request";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return testAndRead(LineAddress, DataBlk, pkt);
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     return testAndWrite(LineAddress, DataBlk, pkt);
   }
 }
diff --git a/src/mem/protocol/Network_test-msg.sm b/src/mem/protocol/Network_test-msg.sm
--- a/src/mem/protocol/Network_test-msg.sm
+++ b/src/mem/protocol/Network_test-msg.sm
@@ -41,11 +41,11 @@
   DataBlock DataBlk,           desc="data for the cache line";
   MessageSizeType MessageSize, desc="size category of the message";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     error("Network test does not support functional accesses!");
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     error("Network test does not support functional accesses!");
   }
 }
diff --git a/src/mem/protocol/RubySlicc_Exports.sm b/src/mem/protocol/RubySlicc_Exports.sm
--- a/src/mem/protocol/RubySlicc_Exports.sm
+++ b/src/mem/protocol/RubySlicc_Exports.sm
@@ -289,11 +289,11 @@
   PrefetchBit Prefetch,      desc="Is this a prefetch request";
   MessageSizeType MessageSize;
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return testAndRead(PhysicalAddress, DataBlk, pkt);
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     return testAndWrite(PhysicalAddress, DataBlk, pkt);
   }
 }
diff --git a/src/mem/protocol/RubySlicc_MemControl.sm b/src/mem/protocol/RubySlicc_MemControl.sm
--- a/src/mem/protocol/RubySlicc_MemControl.sm
+++ b/src/mem/protocol/RubySlicc_MemControl.sm
@@ -62,11 +62,11 @@
   bool ReadX,                   desc="Exclusive";
   int Acks,                     desc="How many acks to expect";
 
-  bool functionalRead(Packet *pkt) {
+  bool functionalRead(Packet *pkt, uint32_t block_size_bits) {
     return testAndRead(addr, DataBlk, pkt);
   }
 
-  bool functionalWrite(Packet *pkt) {
+  bool functionalWrite(Packet *pkt, uint32_t block_size_bits) {
     return testAndWrite(addr, DataBlk, pkt);
   }
 }
diff --git a/src/mem/ruby/network/MessageBuffer.hh b/src/mem/ruby/network/MessageBuffer.hh
--- a/src/mem/ruby/network/MessageBuffer.hh
+++ b/src/mem/ruby/network/MessageBuffer.hh
@@ -120,7 +120,7 @@
     // to be updated with the data from the packet.
     // Return value indicates the number of messages that were updated.
     // This required for debugging the code.
-    uint32_t functionalWrite(Packet *pkt);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     void reanalyzeList(std::list<MsgPtr> &, Tick);
diff --git a/src/mem/ruby/network/MessageBuffer.cc b/src/mem/ruby/network/MessageBuffer.cc
--- a/src/mem/ruby/network/MessageBuffer.cc
+++ b/src/mem/ruby/network/MessageBuffer.cc
@@ -351,7 +351,7 @@
 }
 
 uint32_t
-MessageBuffer::functionalWrite(Packet *pkt)
+MessageBuffer::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
 
@@ -359,7 +359,7 @@
     // correspond to the address in the packet.
     for (unsigned int i = 0; i < m_prio_heap.size(); ++i) {
         Message *msg = m_prio_heap[i].get();
-        if (msg->functionalWrite(pkt)) {
+        if (msg->functionalWrite(pkt, block_size_bits)) {
             num_functional_writes++;
         }
     }
@@ -374,7 +374,7 @@
             it != (map_iter->second).end(); ++it) {
 
             Message *msg = (*it).get();
-            if (msg->functionalWrite(pkt)) {
+            if (msg->functionalWrite(pkt, block_size_bits)) {
                 num_functional_writes++;
             }
         }
diff --git a/src/mem/ruby/network/Network.hh b/src/mem/ruby/network/Network.hh
--- a/src/mem/ruby/network/Network.hh
+++ b/src/mem/ruby/network/Network.hh
@@ -98,9 +98,9 @@
      * the network. Each network needs to implement these for functional
      * accesses to work correctly.
      */
-    virtual bool functionalRead(Packet *pkt)
+    virtual bool functionalRead(Packet *pkt, uint32_t block_size_bits)
     { fatal("Functional read not implemented.\n"); }
-    virtual uint32_t functionalWrite(Packet *pkt)
+    virtual uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits)
     { fatal("Functional write not implemented.\n"); }
 
   protected:
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.hh
--- a/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.hh
@@ -81,7 +81,7 @@
 
     //! Function for performing a functional write. The return value
     //! indicates the number of messages that were written.
-    uint32_t functionalWrite(Packet *pkt);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
 
   private:
     GarnetNetwork_d(const GarnetNetwork_d& obj);
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.cc b/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.cc
--- a/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.cc
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/GarnetNetwork_d.cc
@@ -241,20 +241,23 @@
 }
 
 uint32_t
-GarnetNetwork_d::functionalWrite(Packet *pkt)
+GarnetNetwork_d::functionalWrite(Packet *pkt, uint32_t block_size_bits)
 {
     uint32_t num_functional_writes = 0;
 
     for (unsigned int i = 0; i < m_routers.size(); i++) {
-        num_functional_writes += m_routers[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_routers[i]->functionalWrite(pkt, block_size_bits);
     }
 
     for (unsigned int i = 0; i < m_nis.size(); ++i) {
-        num_functional_writes += m_nis[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_nis[i]->functionalWrite(pkt, block_size_bits);
     }
 
     for (unsigned int i = 0; i < m_links.size(); ++i) {
-        num_functional_writes += m_links[i]->functionalWrite(pkt);
+        num_functional_writes +=
+            m_links[i]->functionalWrite(pkt, block_size_bits);
     }
 
     return num_functional_writes;
diff --git a/src/mem/ruby/network/garnet/fixed-pipeline/InputUnit_d.hh b/src/mem/ruby/network/garnet/fixed-pipeline/InputUnit_d.hh
--- a/src/mem/ruby/network/garnet/fixed-pipeline/InputUnit_d.hh
+++ b/src/mem/ruby/network/garnet/fixed-pipeline/InputUnit_d.hh
@@ -158,7 +158,7 @@
     double get_buf_write_count(unsigned int vnet) const
     { return m_num_buffer_writes[vnet]; }
 
-    uint32_t functionalWrite(Packet *pkt);
+    uint32_t functionalWrite(Packet *pkt, uint32_t block_size_bits);
     void resetStats();
 
   private: