Changeset 21128 in vbox for trunk

Timestamp:

Jul 1, 2009 2:46:19 PM (16 years ago)

Author:

vboxsync

Message:

PDMQueue: Fixed the flushing loop when a consumer (NAT?) had had enough.

Location:

trunk/src/VBox/VMM

Files:

• PDMInternal.h (modified) (2 diffs)
• PDMQueue.cpp (modified) (1 diff)
• VMMAll/PDMAllQueue.cpp (modified) (1 diff)

trunk/src/VBox/VMM/PDMInternal.h

@@ -724 +724 @@
 } PDMQUEUE;
 
+/** @name PDM::fQueueFlushing
+ * @{ */
+/** Indicating that an queue insert has been performed. */
+#define PDM_QUEUE_FLUSH_FLAG_ACTIVE         RT_BIT_32(PDM_QUEUE_FLUSH_FLAG_ACTIVE_BIT)
+/** The bit number for PDM_QUEUE_FLUSH_FLAG_ACTIVE_BIT.  */
+#define PDM_QUEUE_FLUSH_FLAG_ACTIVE_BIT     0
+/** Indicating there are pending items.
+ * This is make sure we don't miss inserts happening during flushing. The FF
+ * cannot be used for this since it has to be cleared immediately to prevent
+ * other EMTs from spinning. */
+#define PDM_QUEUE_FLUSH_FLAG_PENDING        RT_BIT_32(PDM_QUEUE_FLUSH_FLAG_PENDING_BIT)
+/** The bit number for PDM_QUEUE_FLUSH_FLAG_PENDING.  */
+#define PDM_QUEUE_FLUSH_FLAG_PENDING_BIT    1
+/** }@  */
+
 
 /**
@@ -888 +903 @@
      * Only touched by EMT. */
     RCPTRTYPE(struct PDMQUEUE *)    pQueueFlushRC;
-    /** Set if we're currently checking queues to prevent other VCPUs from doing the same concurrently. */
-    volatile uint32_t               fQueueFlushing;
+    /** Bitmask controlling the queue flushing.
+     * See PDM_QUEUE_FLUSH_FLAG_ACTIVE and PDM_QUEUE_FLUSH_FLAG_PENDING. */
+    uint32_t volatile               fQueueFlushing;
 
     /** Head of the PDM Thread list. (singly linked) */

trunk/src/VBox/VMM/PDMQueue.cpp

@@ -627 +627 @@
     LogFlow(("PDMR3QueuesFlush:\n"));
 
+    /*
+     * Only let one EMT flushing queues at any one time to queue preserve order
+     * and to avoid wasting time. The FF is always cleared here, because it's
+     * only used to get someones attention. Queue inserts occuring during the
+     * flush are caught using the pending bit.
+     *
+     * Note. The order in which the FF and pending bit are set and cleared is important.
+     */
     VM_FF_CLEAR(pVM, VM_FF_PDM_QUEUES);
-
-check_queue:
-    /* Prevent other VCPUs from flushing queues at the same time; we'll never flush an item twice, but the order might change. */
-    if (ASMAtomicCmpXchgU32(&pVM->pdm.s.fQueueFlushing, 1, 0))
-    {
-        /* Use atomic test and clear to prevent useless checks; pdmR3QueueFlush is SMP safe. */
+    if (!ASMAtomicBitTestAndSet(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_ACTIVE_BIT))
+    {
+        ASMAtomicBitClear(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_PENDING_BIT);
         do
         {
             for (PPDMQUEUE pCur = pVM->pdm.s.pQueuesForced; pCur; pCur = pCur->pNext)
-            {
                 if (    pCur->pPendingR3
                     ||  pCur->pPendingR0
                     ||  pCur->pPendingRC)
-                {
-                    if (    pdmR3QueueFlush(pCur)
-                        &&  (   pCur->pPendingR3
-                             || pCur->pPendingR0))
-                        /* new items arrived while flushing. */
-                        pdmR3QueueFlush(pCur);
-                }
-            }
-        }
-        while (VM_FF_TESTANDCLEAR(pVM, VM_FF_PDM_QUEUES_BIT));
-
-        ASMAtomicXchgU32(&pVM->pdm.s.fQueueFlushing, 0);
-
-        /* Check if we missed anything. */
-        for (PPDMQUEUE pCur = pVM->pdm.s.pQueuesForced; pCur; pCur = pCur->pNext)
-        {
-            if (    pCur->pPendingR3
-                ||  pCur->pPendingR0
-                ||  pCur->pPendingRC)
-            {
-                VM_FF_SET(pVM, VM_FF_PDM_QUEUES);
-                break;
-            }
-        }
-        if (VM_FF_TESTANDCLEAR(pVM, VM_FF_PDM_QUEUES_BIT))
-            goto check_queue;
-
+                    pdmR3QueueFlush(pCur);
+            VM_FF_CLEAR(pVM, VM_FF_PDM_QUEUES);
+        } while (ASMAtomicBitTestAndClear(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_PENDING_BIT));
+
+        ASMAtomicBitClear(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_ACTIVE_BIT);
     }
 }

trunk/src/VBox/VMM/VMMAll/PDMAllQueue.cpp

@@ -92 +92 @@
         Log2(("PDMQueueInsert: VM_FF_PDM_QUEUES %d -> 1\n", VM_FF_ISSET(pVM, VM_FF_PDM_QUEUES)));
         VM_FF_SET(pVM, VM_FF_PDM_QUEUES);
+        ASMAtomicBitSet(&pVM->pdm.s.fQueueFlushing, PDM_QUEUE_FLUSH_FLAG_PENDING_BIT);
 #ifdef IN_RING3
         REMR3NotifyQueuePending(pVM); /** @todo r=bird: we can remove REMR3NotifyQueuePending and let VMR3NotifyFF do the work. */