Rx: avoid lock churn in rxi_ReceiveAckPacket
authorJeffrey Altman <jaltman@your-file-system.com>
Sun, 19 Sep 2010 16:35:03 +0000 (09:35 -0700)
committerDerrick Brashear <shadow@dementia.org>
Mon, 20 Sep 2010 08:53:00 +0000 (01:53 -0700)
rxi_ReceiveAckPacket can acquire and drop the conn_data_lock several
times and acquires and drops the peer_lock unnecessarily.  This patchset
adds a variable to track whether the conn_data_lock is held in order
to avoid the need to drop it and reacquire it based upon conditional
operations.  It also relocates the peer->maxPacketSize computations
in order to consolidate the work performed under the peer_lock.

Change-Id: I0bc9e42e8ef198a04315f9f2df529073ce9dfd03
Reviewed-on: http://gerrit.openafs.org/2781
Reviewed-by: Derrick Brashear <shadow@dementia.org>
Tested-by: Derrick Brashear <shadow@dementia.org>

src/rx/rx.c

index a3fb69a..8ca6f00 100644 (file)
@@ -3829,6 +3829,7 @@ rxi_ReceiveAckPacket(struct rx_call *call, struct rx_packet *np,
     int newAckCount = 0;
     int maxDgramPackets = 0;   /* Set if peer supports AFS 3.5 jumbo datagrams */
     int pktsize = 0;            /* Set if we need to update the peer mtu */
+    int conn_data_locked = 0;
 
     if (rx_stats_active)
         rx_MutexIncrement(rx_stats.ackPacketsRead, rx_stats_mutex);
@@ -3858,42 +3859,28 @@ rxi_ReceiveAckPacket(struct rx_call *call, struct rx_packet *np,
 
     if (conn->lastPacketSizeSeq) {
        MUTEX_ENTER(&conn->conn_data_lock);
+        conn_data_locked = 1;
        if ((first > conn->lastPacketSizeSeq) && (conn->lastPacketSize)) {
            pktsize = conn->lastPacketSize;
            conn->lastPacketSize = conn->lastPacketSizeSeq = 0;
        }
-       MUTEX_EXIT(&conn->conn_data_lock);
     }
     if ((ap->reason == RX_ACK_PING_RESPONSE) && (conn->lastPingSizeSer)) {
-       MUTEX_ENTER(&conn->conn_data_lock);
+        if (!conn_data_locked) {
+            MUTEX_ENTER(&conn->conn_data_lock);
+            conn_data_locked = 1;
+        }
        if ((conn->lastPingSizeSer == serial) && (conn->lastPingSize)) {
            /* process mtu ping ack */
            pktsize = conn->lastPingSize;
            conn->lastPingSizeSer = conn->lastPingSize = 0;
        }
-       MUTEX_EXIT(&conn->conn_data_lock);
     }
 
-    if (pktsize) {
-       MUTEX_ENTER(&peer->peer_lock);
-       /*
-        * Start somewhere. Can't assume we can send what we can receive,
-        * but we are clearly receiving.
-        */
-       if (!peer->maxPacketSize)
-           peer->maxPacketSize = RX_MIN_PACKET_SIZE+RX_IPUDP_SIZE;
-
-       if (pktsize > peer->maxPacketSize) {
-           peer->maxPacketSize = pktsize;
-           if ((pktsize-RX_IPUDP_SIZE > peer->ifMTU)) {
-               peer->ifMTU=pktsize-RX_IPUDP_SIZE;
-               peer->natMTU = rxi_AdjustIfMTU(peer->ifMTU);
-               rxi_ScheduleGrowMTUEvent(call, 1);
-           }
-       }
-       MUTEX_EXIT(&peer->peer_lock);
+    if (conn_data_locked) {
+       MUTEX_EXIT(&conn->conn_data_lock);
+        conn_data_locked = 0;
     }
-
 #ifdef RXDEBUG
 #ifdef AFS_NT40_ENV
     if (rxdebug_active) {
@@ -3934,11 +3921,29 @@ rxi_ReceiveAckPacket(struct rx_call *call, struct rx_packet *np,
 #endif /* AFS_NT40_ENV */
 #endif
 
+    MUTEX_ENTER(&peer->peer_lock);
+    if (pktsize) {
+       /*
+        * Start somewhere. Can't assume we can send what we can receive,
+        * but we are clearly receiving.
+        */
+       if (!peer->maxPacketSize)
+           peer->maxPacketSize = RX_MIN_PACKET_SIZE+RX_IPUDP_SIZE;
+
+       if (pktsize > peer->maxPacketSize) {
+           peer->maxPacketSize = pktsize;
+           if ((pktsize-RX_IPUDP_SIZE > peer->ifMTU)) {
+               peer->ifMTU=pktsize-RX_IPUDP_SIZE;
+               peer->natMTU = rxi_AdjustIfMTU(peer->ifMTU);
+               rxi_ScheduleGrowMTUEvent(call, 1);
+           }
+       }
+    }
+
     /* Update the outgoing packet skew value to the latest value of
      * the peer's incoming packet skew value.  The ack packet, of
      * course, could arrive out of order, but that won't affect things
      * much */
-    MUTEX_ENTER(&peer->peer_lock);
     peer->outPacketSkew = skew;
 
     /* Check for packets that no longer need to be transmitted, and