diff --git a/lib/ChangeLog b/lib/ChangeLog
index 600ffef..6c54cd3 100644
--- a/lib/ChangeLog
+++ b/lib/ChangeLog
@@ -1,3 +1,13 @@
+2006-02-02 Paul Jakma <paul.jakma@sun.com>
+
+	* workqueue.h: (struct work_queue) Remove the delay field.
+	  It served no purpose and just introduced bad behaviour.
+	  Should be excised before its allowed to escape into 1.0.
+	  This removes need for the 'flood' and runs_since_clear
+	  fields.
+	* workqueue.c: (general) excise delay factor between queue
+	  runs, hence the 'flood' crap too.. See above.
+
 2006-01-19 Paul Jakma <paul.jakma@sun.com>
 
 	* stream.c: (stream_getq_from) should use POSIX uint64_t
diff --git a/lib/workqueue.c b/lib/workqueue.c
index 0c61f5c..1fa16de 100644
--- a/lib/workqueue.c
+++ b/lib/workqueue.c
@@ -82,9 +82,7 @@
   new->cycles.granularity = WORK_QUEUE_MIN_GRANULARITY;
 
   /* Default values, can be overriden by caller */
-  new->spec.delay = WORK_QUEUE_DEFAULT_DELAY;
   new->spec.hold = WORK_QUEUE_DEFAULT_HOLD;
-  new->spec.flood = WORK_QUEUE_DEFAULT_FLOOD;
     
   return new;
 }
@@ -133,7 +131,7 @@
   item->data = data;
   listnode_add (wq->items, item);
   
-  work_queue_schedule (wq, wq->spec.delay);
+  work_queue_schedule (wq, wq->spec.hold);
   
   return;
 }
@@ -172,14 +170,14 @@
   struct work_queue *wq;
   
   vty_out (vty, 
-           "%c%c %8s %11s %8s %21s%s",
-           ' ', ' ', "List","(ms)   ","Q. Runs","Cycle Counts   ",
+           "%c %8s %5s %8s %21s%s",
+           ' ', "List","(ms) ","Q. Runs","Cycle Counts   ",
            VTY_NEWLINE);
   vty_out (vty,
-           "%c%c %8s %5s %5s %8s %7s %6s %6s %s%s",
-           'P', 'F',
+           "%c %8s %5s %8s %7s %6s %6s %s%s",
+           'P',
            "Items",
-           "Delay","Hold",
+           "Hold",
            "Total",
            "Best","Gran.","Avg.", 
            "Name", 
@@ -187,11 +185,10 @@
  
   for (ALL_LIST_ELEMENTS_RO ((&work_queues), node, wq))
     {
-      vty_out (vty,"%c%c %8d %5d %5d %8ld %7d %6d %6u %s%s",
+      vty_out (vty,"%c %8d %5d %8ld %7d %6d %6u %s%s",
                (wq->flags == WQ_PLUGGED ? 'P' : ' '),
-               (wq->runs_since_clear >= wq->spec.flood ? 'F' : ' '),
                listcount (wq->items),
-               wq->spec.delay, wq->spec.hold,
+               wq->spec.hold,
                wq->runs,
                wq->cycles.best, wq->cycles.granularity,
                  (wq->runs) ? 
@@ -226,7 +223,7 @@
   wq->flags = WQ_UNPLUGGED;
 
   /* if thread isnt already waiting, add one */
-  work_queue_schedule (wq, wq->spec.delay);
+  work_queue_schedule (wq, wq->spec.hold);
 }
 
 /* timer thread to process a work queue
@@ -370,19 +367,9 @@
   
   /* Is the queue done yet? If it is, call the completion callback. */
   if (listcount (wq->items) > 0)
-    {
-      if (++(wq->runs_since_clear) < wq->spec.flood)
-        work_queue_schedule (wq, wq->spec.hold);
-      else
-        work_queue_schedule (wq, 0); /* queue flooded, go into overdrive */
-    }
-  else
-    {
-      wq->runs_since_clear = 0;
-      
-      if (wq->spec.completion_func)
-        wq->spec.completion_func (wq);
-    }
+    work_queue_schedule (wq, 0);
+  else if (wq->spec.completion_func)
+    wq->spec.completion_func (wq);
   
   return 0;
 }
diff --git a/lib/workqueue.h b/lib/workqueue.h
index 0a398de..c06f481 100644
--- a/lib/workqueue.h
+++ b/lib/workqueue.h
@@ -24,10 +24,8 @@
 #ifndef _QUAGGA_WORK_QUEUE_H
 #define _QUAGGA_WORK_QUEUE_H
 
-/* Work queue default hold and cycle times - millisec */
-#define WORK_QUEUE_DEFAULT_HOLD  50  /* hold-time between runs of a queue */
-#define WORK_QUEUE_DEFAULT_DELAY 10  /* minimum delay for queue runs */
-#define WORK_QUEUE_DEFAULT_FLOOD 40   /* flood factor, ~2s with prev values */
+/* Hold time for the initial schedule of a queue run, in  millisec */
+#define WORK_QUEUE_DEFAULT_HOLD  50 
 
 /* action value, for use by item processor and item error handlers */
 typedef enum
@@ -90,25 +88,11 @@
     unsigned int max_retries;	
 
     unsigned int hold;	/* hold time for first run, in ms */
-    unsigned int delay; /* min delay between queue runs, in ms */
-    
-    unsigned int flood; /* number of queue runs after which we consider
-                         * queue to be flooded, where the runs are
-                         * consecutive and each has used its full slot,
-                         * and the queue has still not been cleared. If
-                         * the queue is flooded, then we try harder to
-                         * clear it by ignoring the hold and delay
-                         * times. No point sparing CPU resources just
-                         * to use ever more memory resources.
-                         */
   } spec;
   
   /* remaining fields should be opaque to users */
   struct list *items;                 /* queue item list */
   unsigned long runs;                 /* runs count */
-  unsigned int runs_since_clear;      /* number of runs since queue was
-                                       * last cleared
-                                       */
   
   struct {
     unsigned int best;