Xen devel - Jan 2012 - [PATCHv3] sedf: remove useless tracing printk and harmonize comments style.

sched_sedf.c used o have its own mechanism for producing tracing-alike
kind of information (domain block, wakeup, etc.). Nowadays, with an even
not so high number of pCPUs/vCPUs, just trying to enable this makes
the serial console completely unusable, produces tons of very hard to
parse and interpreet logging and can easily livelock Dom0. Moreover,
pretty much the same result this is struggling to get to, is better
achieved by enabling the scheduler-related tracing events, as
it is for the other schedulers (say, credit or credit2).

For all these reasons, this removes that machinery completely. While at
it, check in some cosmetics that harmonize the comments withim themself
and with the rest of the code base.

Signed-off-by: Dario Faggioli <dario.faggioli@citrix.com>

diff -r efaa28639a71 xen/common/sched_sedf.c
--- a/xen/common/sched_sedf.c	Wed Jan 04 16:12:44 2012 +0000
+++ b/xen/common/sched_sedf.c	Thu Jan 05 15:02:30 2012 +0100
@@ -13,14 +13,6 @@
 #include <xen/time.h>
 #include <xen/errno.h>
 
-/*verbosity settings*/
-#define SEDFLEVEL 0
-#define PRINT(_f, _a...)                        \
-    do {                                        \
-        if ( (_f) <= SEDFLEVEL )                \
-            printk(_a );                        \
-    } while ( 0 )
-
 #define SEDF_CPUONLINE(_pool)                                             \
     (((_pool) == NULL) ? &cpupool_free_cpus : (_pool)->cpu_valid)
 
@@ -71,34 +63,35 @@ struct sedf_vcpu_info {
     struct list_head list;
     struct list_head extralist[2];
  
-    /*Parameters for EDF*/
-    s_time_t  period;  /*=(relative deadline)*/
-    s_time_t  slice;  /*=worst case execution time*/
+    /* Parameters for EDF */
+    s_time_t  period;  /* = relative deadline */
+    s_time_t  slice;   /* = worst case execution time */
  
-    /*Advaced Parameters*/
-    /*Latency Scaling*/
+    /* Advaced Parameters */
+
+    /* Latency Scaling */
     s_time_t  period_orig;
     s_time_t  slice_orig;
     s_time_t  latency;
  
-    /*status of domain*/
+    /* Status of domain */
     int       status;
-    /*weights for "Scheduling for beginners/ lazy/ etc." ;)*/
+    /* Weights for "Scheduling for beginners/ lazy/ etc." ;) */
     short     weight;
     short     extraweight;
-    /*Bookkeeping*/
+    /* Bookkeeping */
     s_time_t  deadl_abs;
     s_time_t  sched_start_abs;
     s_time_t  cputime;
-    /* times the domain un-/blocked */
+    /* Times the domain un-/blocked */
     s_time_t  block_abs;
     s_time_t  unblock_abs;
  
-    /*scores for {util, block penalty}-weighted extratime distribution*/
+    /* Scores for {util, block penalty}-weighted extratime distribution */
     int   score[2];
     s_time_t  short_block_lost_tot;
  
-    /*Statistics*/
+    /* Statistics */
     s_time_t  extra_time_tot;
 
 #ifdef SEDF_STATS
@@ -165,18 +158,17 @@ static inline void extraq_del(struct vcp
 {
     struct list_head *list = EXTRALIST(d,i);
     ASSERT(extraq_on(d,i));
-    PRINT(3, "Removing domain %i.%i from L%i extraq\n",
-          d->domain->domain_id, d->vcpu_id, i);
     list_del(list);
     list->next = NULL;
     ASSERT(!extraq_on(d, i));
 }
 
-/* adds a domain to the queue of processes which are aware of extra time. List
-   is sorted by score, where a lower score means higher priority for an extra
-   slice. It also updates the score, by simply subtracting a fixed value from
-   each entry, in order to avoid overflow. The algorithm works by simply
-   charging each domain that recieved extratime with an inverse of its weight.
+/*
+ * Adds a domain to the queue of processes which are aware of extra time. List
+ * is sorted by score, where a lower score means higher priority for an extra
+ * slice. It also updates the score, by simply subtracting a fixed value from
+ * each entry, in order to avoid overflow. The algorithm works by simply
+ * charging each domain that recieved extratime with an inverse of its weight.
  */ 
 static inline void extraq_add_sort_update(struct vcpu *d, int i, int sub)
 {
@@ -185,11 +177,6 @@ static inline void extraq_add_sort_updat
  
     ASSERT(!extraq_on(d,i));
 
-    PRINT(3, "Adding domain %i.%i (score= %i, short_pen=
%"PRIi64")"
-          " to L%i extraq\n",
-          d->domain->domain_id, d->vcpu_id, EDOM_INFO(d)->score[i],
-          EDOM_INFO(d)->short_block_lost_tot, i);
-
     /*
      * Iterate through all elements to find our "hole" and on our way
      * update all the other scores.
@@ -200,25 +187,18 @@ static inline void extraq_add_sort_updat
         curinf->score[i] -= sub;
         if ( EDOM_INFO(d)->score[i] < curinf->score[i] )
             break;
-        PRINT(4,"\tbehind domain %i.%i (score= %i)\n",
-              curinf->vcpu->domain->domain_id,
-              curinf->vcpu->vcpu_id, curinf->score[i]);
     }
 
-    /* cur now contains the element, before which we''ll enqueue. */
-    PRINT(3, "\tlist_add to %p\n", cur->prev);
+    /* cur now contains the element, before which we''ll enqueue */
     list_add(EXTRALIST(d,i),cur->prev);
  
-    /* Continue updating the extraq. */
+    /* Continue updating the extraq */
     if ( (cur != EXTRAQ(d->processor,i)) && sub )
     {
         for ( cur = cur->next; cur != EXTRAQ(d->processor,i); cur =
cur->next )
         {
             curinf = list_entry(cur,struct sedf_vcpu_info, extralist[i]);
             curinf->score[i] -= sub;
-            PRINT(4, "\tupdating domain %i.%i (score= %u)\n",
-                  curinf->vcpu->domain->domain_id, 
-                  curinf->vcpu->vcpu_id, curinf->score[i]);
         }
     }
 
@@ -228,29 +208,14 @@ static inline void extraq_check(struct v
 {
     if ( extraq_on(d, EXTRA_UTIL_Q) )
     {
-        PRINT(2,"Dom %i.%i is on L1 extraQ\n",
-              d->domain->domain_id, d->vcpu_id);
-
         if ( !(EDOM_INFO(d)->status & EXTRA_AWARE) &&
              !extra_runs(EDOM_INFO(d)) )
-        {
             extraq_del(d, EXTRA_UTIL_Q);
-            PRINT(2,"Removed dom %i.%i from L1 extraQ\n",
-                  d->domain->domain_id, d->vcpu_id);
-        }
     }
     else
     {
-        PRINT(2, "Dom %i.%i is NOT on L1 extraQ\n",
-              d->domain->domain_id,
-              d->vcpu_id);
-
         if ( (EDOM_INFO(d)->status & EXTRA_AWARE) &&
sedf_runnable(d) )
-        {
             extraq_add_sort_update(d, EXTRA_UTIL_Q, 0);
-            PRINT(2,"Added dom %i.%i to L1 extraQ\n",
-                  d->domain->domain_id, d->vcpu_id);
-        }
     }
 }
 
@@ -259,7 +224,7 @@ static inline void extraq_check_add_unbl
     struct sedf_vcpu_info *inf = EDOM_INFO(d);
 
     if ( inf->status & EXTRA_AWARE )
-        /* Put on the weighted extraq without updating any scores. */
+        /* Put on the weighted extraq without updating any scores */
         extraq_add_sort_update(d, EXTRA_UTIL_Q, 0);
 }
 
@@ -272,8 +237,6 @@ static inline void __del_from_queue(stru
 {
     struct list_head *list = LIST(d);
     ASSERT(__task_on_queue(d));
-    PRINT(3,"Removing domain %i.%i (bop= %"PRIu64") from
runq/waitq\n",
-          d->domain->domain_id, d->vcpu_id,
PERIOD_BEGIN(EDOM_INFO(d)));
     list_del(list);
     list->next = NULL;
     ASSERT(!__task_on_queue(d));
@@ -286,13 +249,12 @@ static inline void list_insert_sort(
 {
     struct list_head     *cur;
 
-    /* Iterate through all elements to find our "hole". */
+    /* Iterate through all elements to find our "hole" */
     list_for_each( cur, list )
         if ( comp(element, cur) < 0 )
             break;
 
-    /* cur now contains the element, before which we''ll enqueue. */
-    PRINT(3,"\tlist_add to %p\n",cur->prev);
+    /* cur now contains the element, before which we''ll enqueue */
     list_add(element, cur->prev);
 }
 
@@ -310,30 +272,28 @@ static int name##_comp(struct list_head*
         return 1;                                                       \
 }
 
-/* adds a domain to the queue of processes which wait for the beginning of the
-   next period; this list is therefore sortet by this time, which is simply
-   absol. deadline - period
+/*
+ * Adds a domain to the queue of processes which wait for the beginning of the
+ * next period; this list is therefore sortet by this time, which is simply
+ * absol. deadline - period.
  */ 
 DOMAIN_COMPARER(waitq, list, PERIOD_BEGIN(d1), PERIOD_BEGIN(d2));
 static inline void __add_to_waitqueue_sort(struct vcpu *v)
 {
     ASSERT(!__task_on_queue(v));
-    PRINT(3,"Adding domain %i.%i (bop= %"PRIu64") to
waitq\n",
-          v->domain->domain_id, v->vcpu_id,
PERIOD_BEGIN(EDOM_INFO(v)));
     list_insert_sort(WAITQ(v->processor), LIST(v), waitq_comp);
     ASSERT(__task_on_queue(v));
 }
 
-/* adds a domain to the queue of processes which have started their current
-   period and are runnable (i.e. not blocked, dieing,...). The first element
-   on this list is running on the processor, if the list is empty the idle
-   task will run. As we are implementing EDF, this list is sorted by deadlines.
+/*
+ * Adds a domain to the queue of processes which have started their current
+ * period and are runnable (i.e. not blocked, dieing,...). The first element
+ * on this list is running on the processor, if the list is empty the idle
+ * task will run. As we are implementing EDF, this list is sorted by deadlines.
  */ 
 DOMAIN_COMPARER(runq, list, d1->deadl_abs, d2->deadl_abs);
 static inline void __add_to_runqueue_sort(struct vcpu *v)
 {
-    PRINT(3,"Adding domain %i.%i (deadl= %"PRIu64") to
runq\n",
-          v->domain->domain_id, v->vcpu_id,
EDOM_INFO(v)->deadl_abs);
     list_insert_sort(RUNQ(v->processor), LIST(v), runq_comp);
 }
 
@@ -361,12 +321,12 @@ static void *sedf_alloc_vdata(const stru
 
     inf->vcpu = v;
 
-    /* Every VCPU gets an equal share of extratime by default. */
+    /* Every VCPU gets an equal share of extratime by default */
     inf->deadl_abs   = 0;
     inf->latency     = 0;
     inf->status      = EXTRA_AWARE | SEDF_ASLEEP;
     inf->extraweight = 1;
-    /* Upon creation all domain are best-effort. */
+    /* Upon creation all domain are best-effort */
     inf->period      = WEIGHT_PERIOD;
     inf->slice       = 0;
 
@@ -450,21 +410,19 @@ static void desched_edf_dom(s_time_t now
 {
     struct sedf_vcpu_info* inf = EDOM_INFO(d);
 
-    /* Current domain is running in real time mode. */
+    /* Current domain is running in real time mode */
     ASSERT(__task_on_queue(d));
 
-    /* Update the domain''s cputime. */
+    /* Update the domain''s cputime */
     inf->cputime += now - inf->sched_start_abs;
 
-    /*
-     * Scheduling decisions which don''t remove the running domain from
the
-     * runq. 
-     */
+    /* Scheduling decisions which don''t remove the running domain from
+     * the runq */
     if ( (inf->cputime < inf->slice) && sedf_runnable(d) )
         return;
   
     __del_from_queue(d);
-  
+
     /*
      * Manage bookkeeping (i.e. calculate next deadline, memorise
      * overrun-time of slice) of finished domains.
@@ -475,30 +433,30 @@ static void desched_edf_dom(s_time_t now
   
         if ( inf->period < inf->period_orig )
         {
-            /* This domain runs in latency scaling or burst mode. */
+            /* This domain runs in latency scaling or burst mode */
             inf->period *= 2;
             inf->slice  *= 2;
             if ( (inf->period > inf->period_orig) ||
                  (inf->slice > inf->slice_orig) )
             {
-                /* Reset slice and period. */
+                /* Reset slice and period */
                 inf->period = inf->period_orig;
                 inf->slice = inf->slice_orig;
             }
         }
 
-        /* Set next deadline. */
+        /* Set next deadline */
         inf->deadl_abs += inf->period;
     }
  
-    /* Add a runnable domain to the waitqueue. */
+    /* Add a runnable domain to the waitqueue */
     if ( sedf_runnable(d) )
     {
         __add_to_waitqueue_sort(d);
     }
     else
     {
-        /* We have a blocked realtime task -> remove it from exqs too. */
+        /* We have a blocked realtime task -> remove it from exqs too */
         if ( extraq_on(d, EXTRA_PEN_Q) )
             extraq_del(d, EXTRA_PEN_Q);
         if ( extraq_on(d, EXTRA_UTIL_Q) )
@@ -518,8 +476,6 @@ static void update_queues(
     struct list_head     *cur, *tmp;
     struct sedf_vcpu_info *curinf;
  
-    PRINT(3,"Updating waitq..\n");
-
     /*
      * Check for the first elements of the waitqueue, whether their
      * next period has already started.
@@ -527,41 +483,32 @@ static void update_queues(
     list_for_each_safe ( cur, tmp, waitq )
     {
         curinf = list_entry(cur, struct sedf_vcpu_info, list);
-        PRINT(4,"\tLooking @ dom %i.%i\n",
-              curinf->vcpu->domain->domain_id,
curinf->vcpu->vcpu_id);
         if ( PERIOD_BEGIN(curinf) > now )
             break;
         __del_from_queue(curinf->vcpu);
         __add_to_runqueue_sort(curinf->vcpu);
     }
  
-    PRINT(3,"Updating runq..\n");
-
-    /* Process the runq, find domains that are on the runq that
shouldn''t. */
+    /* Process the runq, find domains that are on the runq that
shouldn''t */
     list_for_each_safe ( cur, tmp, runq )
     {
         curinf = list_entry(cur,struct sedf_vcpu_info,list);
-        PRINT(4,"\tLooking @ dom %i.%i\n",
-              curinf->vcpu->domain->domain_id,
curinf->vcpu->vcpu_id);
 
         if ( unlikely(curinf->slice == 0) )
         {
-            /* Ignore domains with empty slice. */
-            PRINT(4,"\tUpdating zero-slice domain %i.%i\n",
-                  curinf->vcpu->domain->domain_id,
-                  curinf->vcpu->vcpu_id);
+            /* Ignore domains with empty slice */
             __del_from_queue(curinf->vcpu);
 
-            /* Move them to their next period. */
+            /* Move them to their next period */
             curinf->deadl_abs += curinf->period;
 
-            /* Ensure that the start of the next period is in the future. */
+            /* Ensure that the start of the next period is in the future */
             if ( unlikely(PERIOD_BEGIN(curinf) < now) )
                 curinf->deadl_abs += 
                     (DIV_UP(now - PERIOD_BEGIN(curinf),
                             curinf->period)) * curinf->period;
 
-            /* Put them back into the queue. */
+            /* Put them back into the queue */
             __add_to_waitqueue_sort(curinf->vcpu);
         }
         else if ( unlikely((curinf->deadl_abs < now) ||
@@ -571,18 +518,18 @@ static void update_queues(
              * We missed the deadline or the slice was already finished.
              * Might hapen because of dom_adj.
              */
-            PRINT(4,"\tDomain %i.%i exceeded it''s deadline/"
-                  "slice (%"PRIu64" / %"PRIu64") now:
%"PRIu64
-                  " cputime: %"PRIu64"\n",
-                  curinf->vcpu->domain->domain_id,
-                  curinf->vcpu->vcpu_id,
-                  curinf->deadl_abs, curinf->slice, now,
-                  curinf->cputime);
+            printk("\tDomain %i.%i exceeded it''s deadline/"
+                   "slice (%"PRIu64" / %"PRIu64") now:
%"PRIu64
+                   " cputime: %"PRIu64"\n",
+                   curinf->vcpu->domain->domain_id,
+                   curinf->vcpu->vcpu_id,
+                   curinf->deadl_abs, curinf->slice, now,
+                   curinf->cputime);
             __del_from_queue(curinf->vcpu);
 
-            /* Common case: we miss one period. */
+            /* Common case: we miss one period */
             curinf->deadl_abs += curinf->period;
-   
+
             /*
              * If we are still behind: modulo arithmetic, force deadline
              * to be in future and aligned to period borders.
@@ -593,7 +540,7 @@ static void update_queues(
                            curinf->period) * curinf->period;
             ASSERT(curinf->deadl_abs >= now);
 
-            /* Give a fresh slice. */
+            /* Give a fresh slice */
             curinf->cputime = 0;
             if ( PERIOD_BEGIN(curinf) > now )
                 __add_to_waitqueue_sort(curinf->vcpu);
@@ -603,17 +550,17 @@ static void update_queues(
         else
             break;
     }
-
-    PRINT(3,"done updating the queues\n");
 }
 
 
-/* removes a domain from the head of the according extraQ and
-   requeues it at a specified position:
-     round-robin extratime: end of extraQ
-     weighted ext.: insert in sorted list by score
-   if the domain is blocked / has regained its short-block-loss
-   time it is not put on any queue */
+/*
+ * removes a domain from the head of the according extraQ and
+ * requeues it at a specified position:
+ *   round-robin extratime: end of extraQ
+ *   weighted ext.: insert in sorted list by score
+ * if the domain is blocked / has regained its short-block-loss
+ * time it is not put on any queue.
+ */
 static void desched_extra_dom(s_time_t now, struct vcpu *d)
 {
     struct sedf_vcpu_info *inf = EDOM_INFO(d);
@@ -622,29 +569,25 @@ static void desched_extra_dom(s_time_t n
 
     ASSERT(extraq_on(d, i));
 
-    /* Unset all running flags. */
+    /* Unset all running flags */
     inf->status  &= ~(EXTRA_RUN_PEN | EXTRA_RUN_UTIL);
-    /* Fresh slice for the next run. */
+    /* Fresh slice for the next run */
     inf->cputime = 0;
-    /* Accumulate total extratime. */
+    /* Accumulate total extratime */
     inf->extra_time_tot += now - inf->sched_start_abs;
     /* Remove extradomain from head of the queue. */
     extraq_del(d, i);
 
-    /* Update the score. */
+    /* Update the score */
     oldscore = inf->score[i];
     if ( i == EXTRA_PEN_Q )
     {
-        /*domain was running in L0 extraq*/
-        /*reduce block lost, probably more sophistication here!*/
+        /* Domain was running in L0 extraq */
+        /* reduce block lost, probably more sophistication here!*/
         /*inf->short_block_lost_tot -= EXTRA_QUANTUM;*/
         inf->short_block_lost_tot -= now - inf->sched_start_abs;
-        PRINT(3,"Domain %i.%i: Short_block_loss:
%"PRIi64"\n",
-              inf->vcpu->domain->domain_id, inf->vcpu->vcpu_id,
-              inf->short_block_lost_tot);
 #if 0
-        /*
-         * KAF: If we don''t exit short-blocking state at this point
+        /* KAF: If we don''t exit short-blocking state at this point
          * domain0 can steal all CPU for up to 10 seconds before
          * scheduling settles down (when competing against another
          * CPU-bound domain). Doing this seems to make things behave
@@ -653,51 +596,59 @@ static void desched_extra_dom(s_time_t n
         if ( inf->short_block_lost_tot <= 0 )
 #endif
         {
-            PRINT(4,"Domain %i.%i compensated short block loss!\n",
-                  inf->vcpu->domain->domain_id,
inf->vcpu->vcpu_id);
-            /*we have (over-)compensated our block penalty*/
+            /* We have (over-)compensated our block penalty */
             inf->short_block_lost_tot = 0;
-            /*we don''t want a place on the penalty queue anymore!*/
+            /* We don''t want a place on the penalty queue anymore! */
             inf->status &= ~EXTRA_WANT_PEN_Q;
             goto check_extra_queues;
         }
 
-        /*we have to go again for another try in the block-extraq,
-          the score is not used incremantally here, as this is
-          already done by recalculating the block_lost*/
+        /*
+         * We have to go again for another try in the block-extraq,
+         * the score is not used incremantally here, as this is
+         * already done by recalculating the block_lost
+         */
         inf->score[EXTRA_PEN_Q] = (inf->period << 10) /
             inf->short_block_lost_tot;
         oldscore = 0;
     }
     else
     {
-        /*domain was running in L1 extraq => score is inverse of
-          utilization and is used somewhat incremental!*/
+        /*
+         * Domain was running in L1 extraq => score is inverse of
+         * utilization and is used somewhat incremental!
+         */
         if ( !inf->extraweight )
-            /*NB: use fixed point arithmetic with 10 bits*/
+        {
+            /* NB: use fixed point arithmetic with 10 bits */
             inf->score[EXTRA_UTIL_Q] = (inf->period << 10) /
                 inf->slice;
+        }
         else
-            /*conversion between realtime utilisation and extrawieght:
-              full (ie 100%) utilization is equivalent to 128 extraweight*/
+        {
+            /*
+             * Conversion between realtime utilisation and extrawieght:
+             * full (ie 100%) utilization is equivalent to 128 extraweight
+             */
             inf->score[EXTRA_UTIL_Q] = (1<<17) / inf->extraweight;
+        }
     }
 
  check_extra_queues:
-    /* Adding a runnable domain to the right queue and removing blocked ones*/
+    /* Adding a runnable domain to the right queue and removing blocked ones */
     if ( sedf_runnable(d) )
     {
-        /*add according to score: weighted round robin*/
+        /* Add according to score: weighted round robin */
         if (((inf->status & EXTRA_AWARE) && (i == EXTRA_UTIL_Q))
||
             ((inf->status & EXTRA_WANT_PEN_Q) && (i ==
EXTRA_PEN_Q)))
             extraq_add_sort_update(d, i, oldscore);
     }
     else
     {
-        /*remove this blocked domain from the waitq!*/
+        /* Remove this blocked domain from the waitq! */
         __del_from_queue(d);
-        /*make sure that we remove a blocked domain from the other
-          extraq too*/
+        /* Make sure that we remove a blocked domain from the other
+         * extraq too. */
         if ( i == EXTRA_PEN_Q )
         {
             if ( extraq_on(d, EXTRA_UTIL_Q) )
@@ -729,8 +680,10 @@ static struct task_slice sedf_do_extra_s
 
     if ( !list_empty(extraq[EXTRA_PEN_Q]) )
     {
-        /*we still have elements on the level 0 extraq 
-          => let those run first!*/
+        /*
+         * We still have elements on the level 0 extraq
+         * => let those run first!
+         */
         runinf   = list_entry(extraq[EXTRA_PEN_Q]->next, 
                               struct sedf_vcpu_info, extralist[EXTRA_PEN_Q]);
         runinf->status |= EXTRA_RUN_PEN;
@@ -744,7 +697,7 @@ static struct task_slice sedf_do_extra_s
     {
         if ( !list_empty(extraq[EXTRA_UTIL_Q]) )
         {
-            /*use elements from the normal extraqueue*/
+            /* Use elements from the normal extraqueue */
             runinf   = list_entry(extraq[EXTRA_UTIL_Q]->next,
                                   struct sedf_vcpu_info,
                                   extralist[EXTRA_UTIL_Q]);
@@ -794,11 +747,13 @@ static void sedf_deinit(const struct sch
 }
 
 
-/* Main scheduling function
-   Reasons for calling this function are:
-   -timeslice for the current period used up
-   -domain on waitqueue has started it''s period
-   -and various others ;) in general: determine which domain to run next*/
+/*
+ * Main scheduling function
+ * Reasons for calling this function are:
+ * -timeslice for the current period used up
+ * -domain on waitqueue has started it''s period
+ * -and various others ;) in general: determine which domain to run next
+ */
 static struct task_slice sedf_do_schedule(
     const struct scheduler *ops, s_time_t now, bool_t tasklet_work_scheduled)
 {
@@ -811,13 +766,15 @@ static struct task_slice sedf_do_schedul
     struct sedf_vcpu_info *runinf, *waitinf;
     struct task_slice      ret;
 
-    /*idle tasks don''t need any of the following stuf*/
+    /* Idle tasks don''t need any of the following stuf */
     if ( is_idle_vcpu(current) )
         goto check_waitq;
- 
-    /* create local state of the status of the domain, in order to avoid
-       inconsistent state during scheduling decisions, because data for
-       vcpu_runnable is not protected by the scheduling lock!*/
+
+    /*
+     * Create local state of the status of the domain, in order to avoid
+     * inconsistent state during scheduling decisions, because data for
+     * vcpu_runnable is not protected by the scheduling lock!
+     */
     if ( !vcpu_runnable(current) )
         inf->status |= SEDF_ASLEEP;
  
@@ -826,7 +783,7 @@ static struct task_slice sedf_do_schedul
 
     if ( unlikely(extra_runs(inf)) )
     {
-        /*special treatment of domains running in extra time*/
+        /* Special treatment of domains running in extra time */
         desched_extra_dom(now, current);
     }
     else 
@@ -836,10 +793,12 @@ static struct task_slice sedf_do_schedul
  check_waitq:
     update_queues(now, runq, waitq);
 
-    /*now simply pick the first domain from the runqueue, which has the
-      earliest deadline, because the list is sorted*/
- 
-    /* Tasklet work (which runs in idle VCPU context) overrides all else. */
+    /*
+     * Now simply pick the first domain from the runqueue, which has the
+     * earliest deadline, because the list is sorted
+     *
+     * Tasklet work (which runs in idle VCPU context) overrides all else.
+     */
     if ( tasklet_work_scheduled ||
          (list_empty(runq) && list_empty(waitq)) ||
          unlikely(!cpumask_test_cpu(cpu, SEDF_CPUONLINE(per_cpu(cpupool,
cpu)))) )
@@ -855,9 +814,11 @@ static struct task_slice sedf_do_schedul
         {
             waitinf  = list_entry(waitq->next,
                                   struct sedf_vcpu_info,list);
-            /*rerun scheduler, when scheduled domain reaches it''s
-              end of slice or the first domain from the waitqueue
-              gets ready*/
+            /*
+             * Rerun scheduler, when scheduled domain reaches it''s
+             * end of slice or the first domain from the waitqueue
+             * gets ready.
+             */
             ret.time = MIN(now + runinf->slice - runinf->cputime,
                            PERIOD_BEGIN(waitinf)) - now;
         }
@@ -869,14 +830,18 @@ static struct task_slice sedf_do_schedul
     else
     {
         waitinf  = list_entry(waitq->next,struct sedf_vcpu_info, list);
-        /*we could not find any suitable domain 
-          => look for domains that are aware of extratime*/
+        /*
+         * We could not find any suitable domain 
+         * => look for domains that are aware of extratime
+         */
         ret = sedf_do_extra_schedule(now, PERIOD_BEGIN(waitinf),
                                      extraq, cpu);
     }
 
-    /*TODO: Do something USEFUL when this happens and find out, why it
-      still can happen!!!*/
+    /*
+     * TODO: Do something USEFUL when this happens and find out, why it
+     * still can happen!!!
+     */
     if ( ret.time < 0)
     {
         printk("Ouch! We are seriously BEHIND schedule!
%"PRIi64"\n",
@@ -896,9 +861,6 @@ static struct task_slice sedf_do_schedul
 
 static void sedf_sleep(const struct scheduler *ops, struct vcpu *d)
 {
-    PRINT(2,"sedf_sleep was called, domain-id %i.%i\n",
-          d->domain->domain_id, d->vcpu_id);
- 
     if ( is_idle_vcpu(d) )
         return;
 
@@ -920,7 +882,8 @@ static void sedf_sleep(const struct sche
 }
 
 
-/* This function wakes up a domain, i.e. moves them into the waitqueue
+/*
+ * This function wakes up a domain, i.e. moves them into the waitqueue
  * things to mention are: admission control is taking place nowhere at
  * the moment, so we can''t be sure, whether it is safe to wake the
domain
  * up at all. Anyway, even if it is safe (total cpu usage <=100%) there are
@@ -994,27 +957,31 @@ static void sedf_sleep(const struct sche
 static void unblock_short_extra_support(
     struct sedf_vcpu_info* inf, s_time_t now)
 {
-    /*this unblocking scheme tries to support the domain, by assigning it
-    a priority in extratime distribution according to the loss of time
-    in this slice due to blocking*/
+    /*
+     * This unblocking scheme tries to support the domain, by assigning it
+     * a priority in extratime distribution according to the loss of time
+     * in this slice due to blocking
+     */
     s_time_t pen;
  
-    /*no more realtime execution in this period!*/
+    /* No more realtime execution in this period! */
     inf->deadl_abs += inf->period;
     if ( likely(inf->block_abs) )
     {
-        //treat blocked time as consumed by the domain*/
+        /* Treat blocked time as consumed by the domain */
         /*inf->cputime += now - inf->block_abs;*/
-        /*penalty is time the domain would have
-          had if it continued to run */
+        /*
+         * Penalty is time the domain would have
+         * had if it continued to run.
+         */
         pen = (inf->slice - inf->cputime);
         if ( pen < 0 )
             pen = 0;
-        /*accumulate all penalties over the periods*/
+        /* Accumulate all penalties over the periods */
         /*inf->short_block_lost_tot += pen;*/
-        /*set penalty to the current value*/
+        /* Set penalty to the current value */
         inf->short_block_lost_tot = pen;
-        /*not sure which one is better.. but seems to work well...*/
+        /* Not sure which one is better.. but seems to work well... */
   
         if ( inf->short_block_lost_tot )
         {
@@ -1024,28 +991,31 @@ static void unblock_short_extra_support(
             inf->pen_extra_blocks++;
 #endif
             if ( extraq_on(inf->vcpu, EXTRA_PEN_Q) )
-                /*remove domain for possible resorting!*/
+                /* Remove domain for possible resorting! */
                 extraq_del(inf->vcpu, EXTRA_PEN_Q);
             else
-                /*remember that we want to be on the penalty q
-                  so that we can continue when we (un-)block
-                  in penalty-extratime*/
+                /*
+                 * Remember that we want to be on the penalty q
+                 * so that we can continue when we (un-)block
+                 * in penalty-extratime
+                 */
                 inf->status |= EXTRA_WANT_PEN_Q;
    
-            /*(re-)add domain to the penalty extraq*/
+            /* (re-)add domain to the penalty extraq */
             extraq_add_sort_update(inf->vcpu, EXTRA_PEN_Q, 0);
         }
     }
 
-    /*give it a fresh slice in the next period!*/
+    /* Give it a fresh slice in the next period! */
     inf->cputime = 0;
 }
 
 
 static void unblock_long_cons_b(struct sedf_vcpu_info* inf,s_time_t now)
 {
-    /*Conservative 2b*/
-    /*Treat the unblocking time as a start of a new period */
+    /* Conservative 2b */
+
+    /* Treat the unblocking time as a start of a new period */
     inf->deadl_abs = now + inf->period;
     inf->cputime = 0;
 }
@@ -1068,15 +1038,17 @@ static inline int get_run_type(struct vc
 }
 
 
-/*Compares two domains in the relation of whether the one is allowed to
-  interrupt the others execution.
-  It returns true (!=0) if a switch to the other domain is good.
-  Current Priority scheme is as follows:
-   EDF > L0 (penalty based) extra-time > 
-   L1 (utilization) extra-time > idle-domain
-  In the same class priorities are assigned as following:
-   EDF: early deadline > late deadline
-   L0 extra-time: lower score > higher score*/
+/*
+ * Compares two domains in the relation of whether the one is allowed to
+ * interrupt the others execution.
+ * It returns true (!=0) if a switch to the other domain is good.
+ * Current Priority scheme is as follows:
+ *  EDF > L0 (penalty based) extra-time > 
+ *  L1 (utilization) extra-time > idle-domain
+ * In the same class priorities are assigned as following:
+ *  EDF: early deadline > late deadline
+ *  L0 extra-time: lower score > higher score
+ */
 static inline int should_switch(struct vcpu *cur,
                                 struct vcpu *other,
                                 s_time_t now)
@@ -1085,26 +1057,25 @@ static inline int should_switch(struct v
     cur_inf   = EDOM_INFO(cur);
     other_inf = EDOM_INFO(other);
  
-    /* Check whether we need to make an earlier scheduling decision. */
+    /* Check whether we need to make an earlier scheduling decision */
     if ( PERIOD_BEGIN(other_inf) < 
          CPU_INFO(other->processor)->current_slice_expires )
         return 1;
 
-    /* No timing-based switches need to be taken into account here. */
+    /* No timing-based switches need to be taken into account here */
     switch ( get_run_type(cur) )
     {
     case DOMAIN_EDF:
-        /* Do not interrupt a running EDF domain. */
+        /* Do not interrupt a running EDF domain */
         return 0;
     case DOMAIN_EXTRA_PEN:
-        /* Check whether we also want the L0 ex-q with lower score. */
+        /* Check whether we also want the L0 ex-q with lower score */
         return ((other_inf->status & EXTRA_WANT_PEN_Q) &&
                 (other_inf->score[EXTRA_PEN_Q] < 
                  cur_inf->score[EXTRA_PEN_Q]));
     case DOMAIN_EXTRA_UTIL:
         /* Check whether we want the L0 extraq. Don''t
-         * switch if both domains want L1 extraq.
-         */
+         * switch if both domains want L1 extraq. */
         return !!(other_inf->status & EXTRA_WANT_PEN_Q);
     case DOMAIN_IDLE:
         return 1;
@@ -1118,18 +1089,11 @@ static void sedf_wake(const struct sched
     s_time_t              now = NOW();
     struct sedf_vcpu_info* inf = EDOM_INFO(d);
 
-    PRINT(3, "sedf_wake was called, domain-id
%i.%i\n",d->domain->domain_id,
-          d->vcpu_id);
-
     if ( unlikely(is_idle_vcpu(d)) )
         return;
    
     if ( unlikely(__task_on_queue(d)) )
-    {
-        PRINT(3,"\tdomain %i.%i is already in some queue\n",
-              d->domain->domain_id, d->vcpu_id);
         return;
-    }
 
     ASSERT(!sedf_runnable(d));
     inf->status &= ~SEDF_ASLEEP;
@@ -1138,28 +1102,25 @@ static void sedf_wake(const struct sched
  
     if ( unlikely(inf->deadl_abs == 0) )
     {
-        /*initial setup of the deadline*/
+        /* Initial setup of the deadline */
         inf->deadl_abs = now + inf->slice;
     }
   
-    PRINT(3, "waking up domain %i.%i (deadl= %"PRIu64" period=
%"PRIu64
-          "now= %"PRIu64")\n",
-          d->domain->domain_id, d->vcpu_id, inf->deadl_abs,
inf->period, now);
-
 #ifdef SEDF_STATS 
     inf->block_tot++;
 #endif
 
     if ( unlikely(now < PERIOD_BEGIN(inf)) )
     {
-        PRINT(4,"extratime unblock\n");
-        /* unblocking in extra-time! */
+        /* Unblocking in extra-time! */
         if ( inf->status & EXTRA_WANT_PEN_Q )
         {
-            /*we have a domain that wants compensation
-              for block penalty and did just block in
-              its compensation time. Give it another
-              chance!*/
+            /*
+             * We have a domain that wants compensation
+             * for block penalty and did just block in
+             * its compensation time. Give it another
+             * chance!
+             */
             extraq_add_sort_update(d, EXTRA_PEN_Q, 0);
         }
         extraq_check_add_unblocked(d, 0);
@@ -1168,8 +1129,7 @@ static void sedf_wake(const struct sched
     {  
         if ( now < inf->deadl_abs )
         {
-            PRINT(4,"short unblocking\n");
-            /*short blocking*/
+            /* Short blocking */
 #ifdef SEDF_STATS
             inf->short_block_tot++;
 #endif
@@ -1179,8 +1139,7 @@ static void sedf_wake(const struct sched
         }
         else
         {
-            PRINT(4,"long unblocking\n");
-            /*long unblocking*/
+            /* Long unblocking */
 #ifdef SEDF_STATS
             inf->long_block_tot++;
 #endif
@@ -1190,24 +1149,13 @@ static void sedf_wake(const struct sched
         }
     }
 
-    PRINT(3, "woke up domain %i.%i (deadl= %"PRIu64" period=
%"PRIu64
-          "now= %"PRIu64")\n",
-          d->domain->domain_id, d->vcpu_id, inf->deadl_abs,
-          inf->period, now);
-
     if ( PERIOD_BEGIN(inf) > now )
-    {
         __add_to_waitqueue_sort(d);
-        PRINT(3,"added to waitq\n");
-    }
     else
-    {
         __add_to_runqueue_sort(d);
-        PRINT(3,"added to runq\n");
-    }
  
 #ifdef SEDF_STATS
-    /*do some statistics here...*/
+    /* Do some statistics here... */
     if ( inf->block_abs != 0 )
     {
         inf->block_time_tot += now - inf->block_abs;
@@ -1216,12 +1164,14 @@ static void sedf_wake(const struct sched
     }
 #endif
 
-    /*sanity check: make sure each extra-aware domain IS on the util-q!*/
+    /* Sanity check: make sure each extra-aware domain IS on the util-q! */
     ASSERT(IMPLY(inf->status & EXTRA_AWARE, extraq_on(d,
EXTRA_UTIL_Q)));
     ASSERT(__task_on_queue(d));
-    /*check whether the awakened task needs to invoke the do_schedule
-      routine. Try to avoid unnecessary runs but:
-      Save approximation: Always switch to scheduler!*/
+    /*
+     * Check whether the awakened task needs to invoke the do_schedule
+     * routine. Try to avoid unnecessary runs but:
+     * Save approximation: Always switch to scheduler!
+     */
     ASSERT(d->processor >= 0);
     ASSERT(d->processor < nr_cpu_ids);
     ASSERT(per_cpu(schedule_data, d->processor).curr);
@@ -1266,7 +1216,7 @@ static void sedf_dump_domain(struct vcpu
 }
 
 
-/* dumps all domains on the specified cpu */
+/* Dumps all domains on the specified cpu */
 static void sedf_dump_cpu_state(const struct scheduler *ops, int i)
 {
     struct list_head      *list, *queue, *tmp;
@@ -1341,16 +1291,18 @@ static void sedf_dump_cpu_state(const st
 }
 
 
-/* Adjusts periods and slices of the domains accordingly to their weights. */
+/* Adjusts periods and slices of the domains accordingly to their weights */
 static int sedf_adjust_weights(struct cpupool *c, int nr_cpus, int *sumw,
s_time_t *sumt)
 {
     struct vcpu *p;
     struct domain      *d;
     unsigned int        cpu;
 
-    /* Sum across all weights. Notice that no runq locking is needed
+    /*
+     * Sum across all weights. Notice that no runq locking is needed
      * here: the caller holds sedf_priv_info.lock and we''re not
changing
-     * anything that is accessed during scheduling. */
+     * anything that is accessed during scheduling.
+     */
     rcu_read_lock(&domlist_read_lock);
     for_each_domain_in_cpupool( d, c )
     {
@@ -1365,11 +1317,14 @@ static int sedf_adjust_weights(struct cp
             }
             else
             {
-                /*don''t modify domains who don''t have a
weight, but sum
-                  up the time they need, projected to a WEIGHT_PERIOD,
-                  so that this time is not given to the weight-driven
-                  domains*/
-                /*check for overflows*/
+                /*
+                 * Don''t modify domains who don''t have a
weight, but sum
+                 * up the time they need, projected to a WEIGHT_PERIOD,
+                 * so that this time is not given to the weight-driven
+                 *  domains
+                 */
+
+                /* Check for overflows */
                 ASSERT((WEIGHT_PERIOD < ULONG_MAX) 
                        && (EDOM_INFO(p)->slice_orig <
ULONG_MAX));
                 sumt[cpu] += 
@@ -1380,9 +1335,11 @@ static int sedf_adjust_weights(struct cp
     }
     rcu_read_unlock(&domlist_read_lock);
 
-    /* Adjust all slices (and periods) to the new weight. Unlike above, we
+    /*
+     * Adjust all slices (and periods) to the new weight. Unlike above, we
      * need to take thr runq lock for the various VCPUs: we''re
modyfing
-     * slice and period which are referenced during scheduling. */
+     * slice and period which are referenced during scheduling.
+     */
     rcu_read_lock(&domlist_read_lock);
     for_each_domain_in_cpupool( d, c )
     {
@@ -1410,7 +1367,7 @@ static int sedf_adjust_weights(struct cp
 }
 
 
-/* set or fetch domain scheduling parameters */
+/* Set or fetch domain scheduling parameters */
 static int sedf_adjust(const struct scheduler *ops, struct domain *p, struct
xen_domctl_scheduler_op *op)
 {
     struct sedf_priv_info *prv = SEDF_PRIV(ops);
@@ -1421,23 +1378,22 @@ static int sedf_adjust(const struct sche
     struct vcpu *v;
     int rc = 0;
 
-    PRINT(2,"sedf_adjust was called, domain-id %i new period
%"PRIu64" "
-          "new slice %"PRIu64"\nlatency %"PRIu64"
extra:%s\n",
-          p->domain_id, op->u.sedf.period, op->u.sedf.slice,
-          op->u.sedf.latency,
(op->u.sedf.extratime)?"yes":"no");
-
-    /* Serialize against the pluggable scheduler lock to protect from
+    /*
+     * Serialize against the pluggable scheduler lock to protect from
      * concurrent updates. We need to take the runq lock for the VCPUs
      * as well, since we are touching extraweight, weight, slice and
      * period. As in sched_credit2.c, runq locks nest inside the
-     * pluggable scheduler lock. */
+     * pluggable scheduler lock.
+     */
     spin_lock_irqsave(&prv->lock, flags);
 
     if ( op->cmd == XEN_DOMCTL_SCHEDOP_putinfo )
     {
-        /* These are used in sedf_adjust_weights() but have to be allocated in
+        /*
+         * These are used in sedf_adjust_weights() but have to be allocated in
          * this function, as we need to avoid nesting
xmem_pool_alloc''s lock
-         * within our prv->lock. */
+         * within our prv->lock.
+         */
         if ( !sumw || !sumt )
         {
             /* Check for errors here, the _getinfo branch doesn''t care
*/
@@ -1445,7 +1401,7 @@ static int sedf_adjust(const struct sche
             goto out;
         }
 
-        /* Check for sane parameters. */
+        /* Check for sane parameters */
         if ( !op->u.sedf.period && !op->u.sedf.weight )
         {
             rc = -EINVAL;
@@ -1457,7 +1413,7 @@ static int sedf_adjust(const struct sche
             if ( (op->u.sedf.extratime & EXTRA_AWARE) &&
                  (!op->u.sedf.period) )
             {
-                /* Weight-driven domains with extratime only. */
+                /* Weight-driven domains with extratime only */
                 for_each_vcpu ( p, v )
                 {
                     /* (Here and everywhere in the following) IRQs are already
off,
@@ -1472,7 +1428,7 @@ static int sedf_adjust(const struct sche
             }
             else
             {
-                /* Weight-driven domains with real-time execution. */
+                /* Weight-driven domains with real-time execution */
                 for_each_vcpu ( p, v ) {
                     vcpu_schedule_lock(v);
                     EDOM_INFO(v)->weight = op->u.sedf.weight;
@@ -1495,7 +1451,7 @@ static int sedf_adjust(const struct sche
                 goto out;
             }
 
-            /* Time-driven domains. */
+            /* Time-driven domains */
             for_each_vcpu ( p, v )
             {
                 vcpu_schedule_lock(v);
@@ -1545,7 +1501,6 @@ out:
     xfree(sumt);
     xfree(sumw);
 
-    PRINT(2,"sedf_adjust_finished with return code %d\n", rc);
     return rc;
 }
 

-- 
<<This happens because I choose it to happen!>> (Raistlin Majere)
-------------------------------------------------------------------
Dario Faggioli, http://retis.sssup.it/people/faggioli
Senior Software Engineer, Citrix Systems R&D Ltd., Cambridge (UK)
PhD Candidate, ReTiS Lab, Scuola Superiore Sant''Anna, Pisa (Italy)




_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xensource.com
http://lists.xensource.com/xen-devel

Dario,

This patch has word-wrap damage.  I''m afraid you''re going to
have to
either send it as an attachment or use hg email.

 -George

On Thu, Jan 5, 2012 at 10:17 AM, Dario Faggioli <raistlin@linux.it>
wrote:
> sched_sedf.c used o have its own mechanism for producing tracing-alike
> kind of information (domain block, wakeup, etc.). Nowadays, with an even
> not so high number of pCPUs/vCPUs, just trying to enable this makes
> the serial console completely unusable, produces tons of very hard to
> parse and interpreet logging and can easily livelock Dom0. Moreover,
> pretty much the same result this is struggling to get to, is better
> achieved by enabling the scheduler-related tracing events, as
> it is for the other schedulers (say, credit or credit2).
>
> For all these reasons, this removes that machinery completely. While at
> it, check in some cosmetics that harmonize the comments withim themself
> and with the rest of the code base.
>
> Signed-off-by: Dario Faggioli <dario.faggioli@citrix.com>
>
> diff -r efaa28639a71 xen/common/sched_sedf.c
> --- a/xen/common/sched_sedf.c   Wed Jan 04 16:12:44 2012 +0000
> +++ b/xen/common/sched_sedf.c   Thu Jan 05 15:02:30 2012 +0100
> @@ -13,14 +13,6 @@
>  #include <xen/time.h>
>  #include <xen/errno.h>
>
> -/*verbosity settings*/
> -#define SEDFLEVEL 0
> -#define PRINT(_f, _a...)                        \
> -    do {                                        \
> -        if ( (_f) <= SEDFLEVEL )                \
> -            printk(_a );                        \
> -    } while ( 0 )
> -
>  #define SEDF_CPUONLINE(_pool)                                            
\
>     (((_pool) == NULL) ? &cpupool_free_cpus : (_pool)->cpu_valid)
>
> @@ -71,34 +63,35 @@ struct sedf_vcpu_info {
>     struct list_head list;
>     struct list_head extralist[2];
>
> -    /*Parameters for EDF*/
> -    s_time_t  period;  /*=(relative deadline)*/
> -    s_time_t  slice;  /*=worst case execution time*/
> +    /* Parameters for EDF */
> +    s_time_t  period;  /* = relative deadline */
> +    s_time_t  slice;   /* = worst case execution time */
>
> -    /*Advaced Parameters*/
> -    /*Latency Scaling*/
> +    /* Advaced Parameters */
> +
> +    /* Latency Scaling */
>     s_time_t  period_orig;
>     s_time_t  slice_orig;
>     s_time_t  latency;
>
> -    /*status of domain*/
> +    /* Status of domain */
>     int       status;
> -    /*weights for "Scheduling for beginners/ lazy/ etc." ;)*/
> +    /* Weights for "Scheduling for beginners/ lazy/ etc." ;) */
>     short     weight;
>     short     extraweight;
> -    /*Bookkeeping*/
> +    /* Bookkeeping */
>     s_time_t  deadl_abs;
>     s_time_t  sched_start_abs;
>     s_time_t  cputime;
> -    /* times the domain un-/blocked */
> +    /* Times the domain un-/blocked */
>     s_time_t  block_abs;
>     s_time_t  unblock_abs;
>
> -    /*scores for {util, block penalty}-weighted extratime distribution*/
> +    /* Scores for {util, block penalty}-weighted extratime distribution */
>     int   score[2];
>     s_time_t  short_block_lost_tot;
>
> -    /*Statistics*/
> +    /* Statistics */
>     s_time_t  extra_time_tot;
>
>  #ifdef SEDF_STATS
> @@ -165,18 +158,17 @@ static inline void extraq_del(struct vcp
>  {
>     struct list_head *list = EXTRALIST(d,i);
>     ASSERT(extraq_on(d,i));
> -    PRINT(3, "Removing domain %i.%i from L%i extraq\n",
> -          d->domain->domain_id, d->vcpu_id, i);
>     list_del(list);
>     list->next = NULL;
>     ASSERT(!extraq_on(d, i));
>  }
>
> -/* adds a domain to the queue of processes which are aware of extra time.
List
> -   is sorted by score, where a lower score means higher priority for an
extra
> -   slice. It also updates the score, by simply subtracting a fixed value
from
> -   each entry, in order to avoid overflow. The algorithm works by simply
> -   charging each domain that recieved extratime with an inverse of its
weight.
> +/*
> + * Adds a domain to the queue of processes which are aware of extra time.
List
> + * is sorted by score, where a lower score means higher priority for an
extra
> + * slice. It also updates the score, by simply subtracting a fixed value
from
> + * each entry, in order to avoid overflow. The algorithm works by simply
> + * charging each domain that recieved extratime with an inverse of its
weight.
>  */
>  static inline void extraq_add_sort_update(struct vcpu *d, int i, int sub)
>  {
> @@ -185,11 +177,6 @@ static inline void extraq_add_sort_updat
>
>     ASSERT(!extraq_on(d,i));
>
> -    PRINT(3, "Adding domain %i.%i (score= %i, short_pen=
%"PRIi64")"
> -          " to L%i extraq\n",
> -          d->domain->domain_id, d->vcpu_id,
EDOM_INFO(d)->score[i],
> -          EDOM_INFO(d)->short_block_lost_tot, i);
> -
>     /*
>      * Iterate through all elements to find our "hole" and on our
way
>      * update all the other scores.
> @@ -200,25 +187,18 @@ static inline void extraq_add_sort_updat
>         curinf->score[i] -= sub;
>         if ( EDOM_INFO(d)->score[i] < curinf->score[i] )
>             break;
> -        PRINT(4,"\tbehind domain %i.%i (score= %i)\n",
> -              curinf->vcpu->domain->domain_id,
> -              curinf->vcpu->vcpu_id, curinf->score[i]);
>     }
>
> -    /* cur now contains the element, before which we''ll enqueue.
*/
> -    PRINT(3, "\tlist_add to %p\n", cur->prev);
> +    /* cur now contains the element, before which we''ll enqueue
*/
>     list_add(EXTRALIST(d,i),cur->prev);
>
> -    /* Continue updating the extraq. */
> +    /* Continue updating the extraq */
>     if ( (cur != EXTRAQ(d->processor,i)) && sub )
>     {
>         for ( cur = cur->next; cur != EXTRAQ(d->processor,i); cur =
cur->next )
>         {
>             curinf = list_entry(cur,struct sedf_vcpu_info, extralist[i]);
>             curinf->score[i] -= sub;
> -            PRINT(4, "\tupdating domain %i.%i (score= %u)\n",
> -                  curinf->vcpu->domain->domain_id,
> -                  curinf->vcpu->vcpu_id, curinf->score[i]);
>         }
>     }
>
> @@ -228,29 +208,14 @@ static inline void extraq_check(struct v
>  {
>     if ( extraq_on(d, EXTRA_UTIL_Q) )
>     {
> -        PRINT(2,"Dom %i.%i is on L1 extraQ\n",
> -              d->domain->domain_id, d->vcpu_id);
> -
>         if ( !(EDOM_INFO(d)->status & EXTRA_AWARE) &&
>              !extra_runs(EDOM_INFO(d)) )
> -        {
>             extraq_del(d, EXTRA_UTIL_Q);
> -            PRINT(2,"Removed dom %i.%i from L1 extraQ\n",
> -                  d->domain->domain_id, d->vcpu_id);
> -        }
>     }
>     else
>     {
> -        PRINT(2, "Dom %i.%i is NOT on L1 extraQ\n",
> -              d->domain->domain_id,
> -              d->vcpu_id);
> -
>         if ( (EDOM_INFO(d)->status & EXTRA_AWARE) &&
sedf_runnable(d) )
> -        {
>             extraq_add_sort_update(d, EXTRA_UTIL_Q, 0);
> -            PRINT(2,"Added dom %i.%i to L1 extraQ\n",
> -                  d->domain->domain_id, d->vcpu_id);
> -        }
>     }
>  }
>
> @@ -259,7 +224,7 @@ static inline void extraq_check_add_unbl
>     struct sedf_vcpu_info *inf = EDOM_INFO(d);
>
>     if ( inf->status & EXTRA_AWARE )
> -        /* Put on the weighted extraq without updating any scores. */
> +        /* Put on the weighted extraq without updating any scores */
>         extraq_add_sort_update(d, EXTRA_UTIL_Q, 0);
>  }
>
> @@ -272,8 +237,6 @@ static inline void __del_from_queue(stru
>  {
>     struct list_head *list = LIST(d);
>     ASSERT(__task_on_queue(d));
> -    PRINT(3,"Removing domain %i.%i (bop= %"PRIu64") from
runq/waitq\n",
> -          d->domain->domain_id, d->vcpu_id,
PERIOD_BEGIN(EDOM_INFO(d)));
>     list_del(list);
>     list->next = NULL;
>     ASSERT(!__task_on_queue(d));
> @@ -286,13 +249,12 @@ static inline void list_insert_sort(
>  {
>     struct list_head     *cur;
>
> -    /* Iterate through all elements to find our "hole". */
> +    /* Iterate through all elements to find our "hole" */
>     list_for_each( cur, list )
>         if ( comp(element, cur) < 0 )
>             break;
>
> -    /* cur now contains the element, before which we''ll enqueue.
*/
> -    PRINT(3,"\tlist_add to %p\n",cur->prev);
> +    /* cur now contains the element, before which we''ll enqueue
*/
>     list_add(element, cur->prev);
>  }
>
> @@ -310,30 +272,28 @@ static int name##_comp(struct list_head*
>         return 1;                                                       \
>  }
>
> -/* adds a domain to the queue of processes which wait for the beginning of
the
> -   next period; this list is therefore sortet by this time, which is
simply
> -   absol. deadline - period
> +/*
> + * Adds a domain to the queue of processes which wait for the beginning of
the
> + * next period; this list is therefore sortet by this time, which is
simply
> + * absol. deadline - period.
>  */
>  DOMAIN_COMPARER(waitq, list, PERIOD_BEGIN(d1), PERIOD_BEGIN(d2));
>  static inline void __add_to_waitqueue_sort(struct vcpu *v)
>  {
>     ASSERT(!__task_on_queue(v));
> -    PRINT(3,"Adding domain %i.%i (bop= %"PRIu64") to
waitq\n",
> -          v->domain->domain_id, v->vcpu_id,
PERIOD_BEGIN(EDOM_INFO(v)));
>     list_insert_sort(WAITQ(v->processor), LIST(v), waitq_comp);
>     ASSERT(__task_on_queue(v));
>  }
>
> -/* adds a domain to the queue of processes which have started their
current
> -   period and are runnable (i.e. not blocked, dieing,...). The first
element
> -   on this list is running on the processor, if the list is empty the idle
> -   task will run. As we are implementing EDF, this list is sorted by
deadlines.
> +/*
> + * Adds a domain to the queue of processes which have started their
current
> + * period and are runnable (i.e. not blocked, dieing,...). The first
element
> + * on this list is running on the processor, if the list is empty the idle
> + * task will run. As we are implementing EDF, this list is sorted by
deadlines.
>  */
>  DOMAIN_COMPARER(runq, list, d1->deadl_abs, d2->deadl_abs);
>  static inline void __add_to_runqueue_sort(struct vcpu *v)
>  {
> -    PRINT(3,"Adding domain %i.%i (deadl= %"PRIu64") to
runq\n",
> -          v->domain->domain_id, v->vcpu_id,
EDOM_INFO(v)->deadl_abs);
>     list_insert_sort(RUNQ(v->processor), LIST(v), runq_comp);
>  }
>
> @@ -361,12 +321,12 @@ static void *sedf_alloc_vdata(const stru
>
>     inf->vcpu = v;
>
> -    /* Every VCPU gets an equal share of extratime by default. */
> +    /* Every VCPU gets an equal share of extratime by default */
>     inf->deadl_abs   = 0;
>     inf->latency     = 0;
>     inf->status      = EXTRA_AWARE | SEDF_ASLEEP;
>     inf->extraweight = 1;
> -    /* Upon creation all domain are best-effort. */
> +    /* Upon creation all domain are best-effort */
>     inf->period      = WEIGHT_PERIOD;
>     inf->slice       = 0;
>
> @@ -450,21 +410,19 @@ static void desched_edf_dom(s_time_t now
>  {
>     struct sedf_vcpu_info* inf = EDOM_INFO(d);
>
> -    /* Current domain is running in real time mode. */
> +    /* Current domain is running in real time mode */
>     ASSERT(__task_on_queue(d));
>
> -    /* Update the domain''s cputime. */
> +    /* Update the domain''s cputime */
>     inf->cputime += now - inf->sched_start_abs;
>
> -    /*
> -     * Scheduling decisions which don''t remove the running domain
from the
> -     * runq.
> -     */
> +    /* Scheduling decisions which don''t remove the running domain
from
> +     * the runq */
>     if ( (inf->cputime < inf->slice) && sedf_runnable(d) )
>         return;
>
>     __del_from_queue(d);
> -
> +
>     /*
>      * Manage bookkeeping (i.e. calculate next deadline, memorise
>      * overrun-time of slice) of finished domains.
> @@ -475,30 +433,30 @@ static void desched_edf_dom(s_time_t now
>
>         if ( inf->period < inf->period_orig )
>         {
> -            /* This domain runs in latency scaling or burst mode. */
> +            /* This domain runs in latency scaling or burst mode */
>             inf->period *= 2;
>             inf->slice  *= 2;
>             if ( (inf->period > inf->period_orig) ||
>                  (inf->slice > inf->slice_orig) )
>             {
> -                /* Reset slice and period. */
> +                /* Reset slice and period */
>                 inf->period = inf->period_orig;
>                 inf->slice = inf->slice_orig;
>             }
>         }
>
> -        /* Set next deadline. */
> +        /* Set next deadline */
>         inf->deadl_abs += inf->period;
>     }
>
> -    /* Add a runnable domain to the waitqueue. */
> +    /* Add a runnable domain to the waitqueue */
>     if ( sedf_runnable(d) )
>     {
>         __add_to_waitqueue_sort(d);
>     }
>     else
>     {
> -        /* We have a blocked realtime task -> remove it from exqs too.
*/
> +        /* We have a blocked realtime task -> remove it from exqs too
*/
>         if ( extraq_on(d, EXTRA_PEN_Q) )
>             extraq_del(d, EXTRA_PEN_Q);
>         if ( extraq_on(d, EXTRA_UTIL_Q) )
> @@ -518,8 +476,6 @@ static void update_queues(
>     struct list_head     *cur, *tmp;
>     struct sedf_vcpu_info *curinf;
>
> -    PRINT(3,"Updating waitq..\n");
> -
>     /*
>      * Check for the first elements of the waitqueue, whether their
>      * next period has already started.
> @@ -527,41 +483,32 @@ static void update_queues(
>     list_for_each_safe ( cur, tmp, waitq )
>     {
>         curinf = list_entry(cur, struct sedf_vcpu_info, list);
> -        PRINT(4,"\tLooking @ dom %i.%i\n",
> -              curinf->vcpu->domain->domain_id,
curinf->vcpu->vcpu_id);
>         if ( PERIOD_BEGIN(curinf) > now )
>             break;
>         __del_from_queue(curinf->vcpu);
>         __add_to_runqueue_sort(curinf->vcpu);
>     }
>
> -    PRINT(3,"Updating runq..\n");
> -
> -    /* Process the runq, find domains that are on the runq that
shouldn''t. */
> +    /* Process the runq, find domains that are on the runq that
shouldn''t */
>     list_for_each_safe ( cur, tmp, runq )
>     {
>         curinf = list_entry(cur,struct sedf_vcpu_info,list);
> -        PRINT(4,"\tLooking @ dom %i.%i\n",
> -              curinf->vcpu->domain->domain_id,
curinf->vcpu->vcpu_id);
>
>         if ( unlikely(curinf->slice == 0) )
>         {
> -            /* Ignore domains with empty slice. */
> -            PRINT(4,"\tUpdating zero-slice domain %i.%i\n",
> -                  curinf->vcpu->domain->domain_id,
> -                  curinf->vcpu->vcpu_id);
> +            /* Ignore domains with empty slice */
>             __del_from_queue(curinf->vcpu);
>
> -            /* Move them to their next period. */
> +            /* Move them to their next period */
>             curinf->deadl_abs += curinf->period;
>
> -            /* Ensure that the start of the next period is in the future.
*/
> +            /* Ensure that the start of the next period is in the future
*/
>             if ( unlikely(PERIOD_BEGIN(curinf) < now) )
>                 curinf->deadl_abs +>                     (DIV_UP(now
- PERIOD_BEGIN(curinf),
>                             curinf->period)) * curinf->period;
>
> -            /* Put them back into the queue. */
> +            /* Put them back into the queue */
>             __add_to_waitqueue_sort(curinf->vcpu);
>         }
>         else if ( unlikely((curinf->deadl_abs < now) ||
> @@ -571,18 +518,18 @@ static void update_queues(
>              * We missed the deadline or the slice was already finished.
>              * Might hapen because of dom_adj.
>              */
> -            PRINT(4,"\tDomain %i.%i exceeded it''s
deadline/"
> -                  "slice (%"PRIu64" / %"PRIu64")
now: %"PRIu64
> -                  " cputime: %"PRIu64"\n",
> -                  curinf->vcpu->domain->domain_id,
> -                  curinf->vcpu->vcpu_id,
> -                  curinf->deadl_abs, curinf->slice, now,
> -                  curinf->cputime);
> +            printk("\tDomain %i.%i exceeded it''s
deadline/"
> +                   "slice (%"PRIu64" / %"PRIu64")
now: %"PRIu64
> +                   " cputime: %"PRIu64"\n",
> +                   curinf->vcpu->domain->domain_id,
> +                   curinf->vcpu->vcpu_id,
> +                   curinf->deadl_abs, curinf->slice, now,
> +                   curinf->cputime);
>             __del_from_queue(curinf->vcpu);
>
> -            /* Common case: we miss one period. */
> +            /* Common case: we miss one period */
>             curinf->deadl_abs += curinf->period;
> -
> +
>             /*
>              * If we are still behind: modulo arithmetic, force deadline
>              * to be in future and aligned to period borders.
> @@ -593,7 +540,7 @@ static void update_queues(
>                            curinf->period) * curinf->period;
>             ASSERT(curinf->deadl_abs >= now);
>
> -            /* Give a fresh slice. */
> +            /* Give a fresh slice */
>             curinf->cputime = 0;
>             if ( PERIOD_BEGIN(curinf) > now )
>                 __add_to_waitqueue_sort(curinf->vcpu);
> @@ -603,17 +550,17 @@ static void update_queues(
>         else
>             break;
>     }
> -
> -    PRINT(3,"done updating the queues\n");
>  }
>
>
> -/* removes a domain from the head of the according extraQ and
> -   requeues it at a specified position:
> -     round-robin extratime: end of extraQ
> -     weighted ext.: insert in sorted list by score
> -   if the domain is blocked / has regained its short-block-loss
> -   time it is not put on any queue */
> +/*
> + * removes a domain from the head of the according extraQ and
> + * requeues it at a specified position:
> + *   round-robin extratime: end of extraQ
> + *   weighted ext.: insert in sorted list by score
> + * if the domain is blocked / has regained its short-block-loss
> + * time it is not put on any queue.
> + */
>  static void desched_extra_dom(s_time_t now, struct vcpu *d)
>  {
>     struct sedf_vcpu_info *inf = EDOM_INFO(d);
> @@ -622,29 +569,25 @@ static void desched_extra_dom(s_time_t n
>
>     ASSERT(extraq_on(d, i));
>
> -    /* Unset all running flags. */
> +    /* Unset all running flags */
>     inf->status  &= ~(EXTRA_RUN_PEN | EXTRA_RUN_UTIL);
> -    /* Fresh slice for the next run. */
> +    /* Fresh slice for the next run */
>     inf->cputime = 0;
> -    /* Accumulate total extratime. */
> +    /* Accumulate total extratime */
>     inf->extra_time_tot += now - inf->sched_start_abs;
>     /* Remove extradomain from head of the queue. */
>     extraq_del(d, i);
>
> -    /* Update the score. */
> +    /* Update the score */
>     oldscore = inf->score[i];
>     if ( i == EXTRA_PEN_Q )
>     {
> -        /*domain was running in L0 extraq*/
> -        /*reduce block lost, probably more sophistication here!*/
> +        /* Domain was running in L0 extraq */
> +        /* reduce block lost, probably more sophistication here!*/
>         /*inf->short_block_lost_tot -= EXTRA_QUANTUM;*/
>         inf->short_block_lost_tot -= now - inf->sched_start_abs;
> -        PRINT(3,"Domain %i.%i: Short_block_loss:
%"PRIi64"\n",
> -              inf->vcpu->domain->domain_id,
inf->vcpu->vcpu_id,
> -              inf->short_block_lost_tot);
>  #if 0
> -        /*
> -         * KAF: If we don''t exit short-blocking state at this
point
> +        /* KAF: If we don''t exit short-blocking state at this
point
>          * domain0 can steal all CPU for up to 10 seconds before
>          * scheduling settles down (when competing against another
>          * CPU-bound domain). Doing this seems to make things behave
> @@ -653,51 +596,59 @@ static void desched_extra_dom(s_time_t n
>         if ( inf->short_block_lost_tot <= 0 )
>  #endif
>         {
> -            PRINT(4,"Domain %i.%i compensated short block
loss!\n",
> -                  inf->vcpu->domain->domain_id,
inf->vcpu->vcpu_id);
> -            /*we have (over-)compensated our block penalty*/
> +            /* We have (over-)compensated our block penalty */
>             inf->short_block_lost_tot = 0;
> -            /*we don''t want a place on the penalty queue
anymore!*/
> +            /* We don''t want a place on the penalty queue
anymore! */
>             inf->status &= ~EXTRA_WANT_PEN_Q;
>             goto check_extra_queues;
>         }
>
> -        /*we have to go again for another try in the block-extraq,
> -          the score is not used incremantally here, as this is
> -          already done by recalculating the block_lost*/
> +        /*
> +         * We have to go again for another try in the block-extraq,
> +         * the score is not used incremantally here, as this is
> +         * already done by recalculating the block_lost
> +         */
>         inf->score[EXTRA_PEN_Q] = (inf->period << 10) /
>             inf->short_block_lost_tot;
>         oldscore = 0;
>     }
>     else
>     {
> -        /*domain was running in L1 extraq => score is inverse of
> -          utilization and is used somewhat incremental!*/
> +        /*
> +         * Domain was running in L1 extraq => score is inverse of
> +         * utilization and is used somewhat incremental!
> +         */
>         if ( !inf->extraweight )
> -            /*NB: use fixed point arithmetic with 10 bits*/
> +        {
> +            /* NB: use fixed point arithmetic with 10 bits */
>             inf->score[EXTRA_UTIL_Q] = (inf->period << 10) /
>                 inf->slice;
> +        }
>         else
> -            /*conversion between realtime utilisation and extrawieght:
> -              full (ie 100%) utilization is equivalent to 128
extraweight*/
> +        {
> +            /*
> +             * Conversion between realtime utilisation and extrawieght:
> +             * full (ie 100%) utilization is equivalent to 128 extraweight
> +             */
>             inf->score[EXTRA_UTIL_Q] = (1<<17) /
inf->extraweight;
> +        }
>     }
>
>  check_extra_queues:
> -    /* Adding a runnable domain to the right queue and removing blocked
ones*/
> +    /* Adding a runnable domain to the right queue and removing blocked
ones */
>     if ( sedf_runnable(d) )
>     {
> -        /*add according to score: weighted round robin*/
> +        /* Add according to score: weighted round robin */
>         if (((inf->status & EXTRA_AWARE) && (i ==
EXTRA_UTIL_Q)) ||
>             ((inf->status & EXTRA_WANT_PEN_Q) && (i ==
EXTRA_PEN_Q)))
>             extraq_add_sort_update(d, i, oldscore);
>     }
>     else
>     {
> -        /*remove this blocked domain from the waitq!*/
> +        /* Remove this blocked domain from the waitq! */
>         __del_from_queue(d);
> -        /*make sure that we remove a blocked domain from the other
> -          extraq too*/
> +        /* Make sure that we remove a blocked domain from the other
> +         * extraq too. */
>         if ( i == EXTRA_PEN_Q )
>         {
>             if ( extraq_on(d, EXTRA_UTIL_Q) )
> @@ -729,8 +680,10 @@ static struct task_slice sedf_do_extra_s
>
>     if ( !list_empty(extraq[EXTRA_PEN_Q]) )
>     {
> -        /*we still have elements on the level 0 extraq
> -          => let those run first!*/
> +        /*
> +         * We still have elements on the level 0 extraq
> +         * => let those run first!
> +         */
>         runinf   = list_entry(extraq[EXTRA_PEN_Q]->next,
>                               struct sedf_vcpu_info,
extralist[EXTRA_PEN_Q]);
>         runinf->status |= EXTRA_RUN_PEN;
> @@ -744,7 +697,7 @@ static struct task_slice sedf_do_extra_s
>     {
>         if ( !list_empty(extraq[EXTRA_UTIL_Q]) )
>         {
> -            /*use elements from the normal extraqueue*/
> +            /* Use elements from the normal extraqueue */
>             runinf   = list_entry(extraq[EXTRA_UTIL_Q]->next,
>                                   struct sedf_vcpu_info,
>                                   extralist[EXTRA_UTIL_Q]);
> @@ -794,11 +747,13 @@ static void sedf_deinit(const struct sch
>  }
>
>
> -/* Main scheduling function
> -   Reasons for calling this function are:
> -   -timeslice for the current period used up
> -   -domain on waitqueue has started it''s period
> -   -and various others ;) in general: determine which domain to run next*/
> +/*
> + * Main scheduling function
> + * Reasons for calling this function are:
> + * -timeslice for the current period used up
> + * -domain on waitqueue has started it''s period
> + * -and various others ;) in general: determine which domain to run next
> + */
>  static struct task_slice sedf_do_schedule(
>     const struct scheduler *ops, s_time_t now, bool_t
tasklet_work_scheduled)
>  {
> @@ -811,13 +766,15 @@ static struct task_slice sedf_do_schedul
>     struct sedf_vcpu_info *runinf, *waitinf;
>     struct task_slice      ret;
>
> -    /*idle tasks don''t need any of the following stuf*/
> +    /* Idle tasks don''t need any of the following stuf */
>     if ( is_idle_vcpu(current) )
>         goto check_waitq;
> -
> -    /* create local state of the status of the domain, in order to avoid
> -       inconsistent state during scheduling decisions, because data for
> -       vcpu_runnable is not protected by the scheduling lock!*/
> +
> +    /*
> +     * Create local state of the status of the domain, in order to avoid
> +     * inconsistent state during scheduling decisions, because data for
> +     * vcpu_runnable is not protected by the scheduling lock!
> +     */
>     if ( !vcpu_runnable(current) )
>         inf->status |= SEDF_ASLEEP;
>
> @@ -826,7 +783,7 @@ static struct task_slice sedf_do_schedul
>
>     if ( unlikely(extra_runs(inf)) )
>     {
> -        /*special treatment of domains running in extra time*/
> +        /* Special treatment of domains running in extra time */
>         desched_extra_dom(now, current);
>     }
>     else
> @@ -836,10 +793,12 @@ static struct task_slice sedf_do_schedul
>  check_waitq:
>     update_queues(now, runq, waitq);
>
> -    /*now simply pick the first domain from the runqueue, which has the
> -      earliest deadline, because the list is sorted*/
> -
> -    /* Tasklet work (which runs in idle VCPU context) overrides all else.
*/
> +    /*
> +     * Now simply pick the first domain from the runqueue, which has the
> +     * earliest deadline, because the list is sorted
> +     *
> +     * Tasklet work (which runs in idle VCPU context) overrides all else.
> +     */
>     if ( tasklet_work_scheduled ||
>          (list_empty(runq) && list_empty(waitq)) ||
>          unlikely(!cpumask_test_cpu(cpu, SEDF_CPUONLINE(per_cpu(cpupool,
cpu)))) )
> @@ -855,9 +814,11 @@ static struct task_slice sedf_do_schedul
>         {
>             waitinf  = list_entry(waitq->next,
>                                   struct sedf_vcpu_info,list);
> -            /*rerun scheduler, when scheduled domain reaches it''s
> -              end of slice or the first domain from the waitqueue
> -              gets ready*/
> +            /*
> +             * Rerun scheduler, when scheduled domain reaches
it''s
> +             * end of slice or the first domain from the waitqueue
> +             * gets ready.
> +             */
>             ret.time = MIN(now + runinf->slice - runinf->cputime,
>                            PERIOD_BEGIN(waitinf)) - now;
>         }
> @@ -869,14 +830,18 @@ static struct task_slice sedf_do_schedul
>     else
>     {
>         waitinf  = list_entry(waitq->next,struct sedf_vcpu_info, list);
> -        /*we could not find any suitable domain
> -          => look for domains that are aware of extratime*/
> +        /*
> +         * We could not find any suitable domain
> +         * => look for domains that are aware of extratime
> +         */
>         ret = sedf_do_extra_schedule(now, PERIOD_BEGIN(waitinf),
>                                      extraq, cpu);
>     }
>
> -    /*TODO: Do something USEFUL when this happens and find out, why it
> -      still can happen!!!*/
> +    /*
> +     * TODO: Do something USEFUL when this happens and find out, why it
> +     * still can happen!!!
> +     */
>     if ( ret.time < 0)
>     {
>         printk("Ouch! We are seriously BEHIND schedule!
%"PRIi64"\n",
> @@ -896,9 +861,6 @@ static struct task_slice sedf_do_schedul
>
>  static void sedf_sleep(const struct scheduler *ops, struct vcpu *d)
>  {
> -    PRINT(2,"sedf_sleep was called, domain-id %i.%i\n",
> -          d->domain->domain_id, d->vcpu_id);
> -
>     if ( is_idle_vcpu(d) )
>         return;
>
> @@ -920,7 +882,8 @@ static void sedf_sleep(const struct sche
>  }
>
>
> -/* This function wakes up a domain, i.e. moves them into the waitqueue
> +/*
> + * This function wakes up a domain, i.e. moves them into the waitqueue
>  * things to mention are: admission control is taking place nowhere at
>  * the moment, so we can''t be sure, whether it is safe to wake the
domain
>  * up at all. Anyway, even if it is safe (total cpu usage <=100%) there
are
> @@ -994,27 +957,31 @@ static void sedf_sleep(const struct sche
>  static void unblock_short_extra_support(
>     struct sedf_vcpu_info* inf, s_time_t now)
>  {
> -    /*this unblocking scheme tries to support the domain, by assigning it
> -    a priority in extratime distribution according to the loss of time
> -    in this slice due to blocking*/
> +    /*
> +     * This unblocking scheme tries to support the domain, by assigning it
> +     * a priority in extratime distribution according to the loss of time
> +     * in this slice due to blocking
> +     */
>     s_time_t pen;
>
> -    /*no more realtime execution in this period!*/
> +    /* No more realtime execution in this period! */
>     inf->deadl_abs += inf->period;
>     if ( likely(inf->block_abs) )
>     {
> -        //treat blocked time as consumed by the domain*/
> +        /* Treat blocked time as consumed by the domain */
>         /*inf->cputime += now - inf->block_abs;*/
> -        /*penalty is time the domain would have
> -          had if it continued to run */
> +        /*
> +         * Penalty is time the domain would have
> +         * had if it continued to run.
> +         */
>         pen = (inf->slice - inf->cputime);
>         if ( pen < 0 )
>             pen = 0;
> -        /*accumulate all penalties over the periods*/
> +        /* Accumulate all penalties over the periods */
>         /*inf->short_block_lost_tot += pen;*/
> -        /*set penalty to the current value*/
> +        /* Set penalty to the current value */
>         inf->short_block_lost_tot = pen;
> -        /*not sure which one is better.. but seems to work well...*/
> +        /* Not sure which one is better.. but seems to work well... */
>
>         if ( inf->short_block_lost_tot )
>         {
> @@ -1024,28 +991,31 @@ static void unblock_short_extra_support(
>             inf->pen_extra_blocks++;
>  #endif
>             if ( extraq_on(inf->vcpu, EXTRA_PEN_Q) )
> -                /*remove domain for possible resorting!*/
> +                /* Remove domain for possible resorting! */
>                 extraq_del(inf->vcpu, EXTRA_PEN_Q);
>             else
> -                /*remember that we want to be on the penalty q
> -                  so that we can continue when we (un-)block
> -                  in penalty-extratime*/
> +                /*
> +                 * Remember that we want to be on the penalty q
> +                 * so that we can continue when we (un-)block
> +                 * in penalty-extratime
> +                 */
>                 inf->status |= EXTRA_WANT_PEN_Q;
>
> -            /*(re-)add domain to the penalty extraq*/
> +            /* (re-)add domain to the penalty extraq */
>             extraq_add_sort_update(inf->vcpu, EXTRA_PEN_Q, 0);
>         }
>     }
>
> -    /*give it a fresh slice in the next period!*/
> +    /* Give it a fresh slice in the next period! */
>     inf->cputime = 0;
>  }
>
>
>  static void unblock_long_cons_b(struct sedf_vcpu_info* inf,s_time_t now)
>  {
> -    /*Conservative 2b*/
> -    /*Treat the unblocking time as a start of a new period */
> +    /* Conservative 2b */
> +
> +    /* Treat the unblocking time as a start of a new period */
>     inf->deadl_abs = now + inf->period;
>     inf->cputime = 0;
>  }
> @@ -1068,15 +1038,17 @@ static inline int get_run_type(struct vc
>  }
>
>
> -/*Compares two domains in the relation of whether the one is allowed to
> -  interrupt the others execution.
> -  It returns true (!=0) if a switch to the other domain is good.
> -  Current Priority scheme is as follows:
> -   EDF > L0 (penalty based) extra-time >
> -   L1 (utilization) extra-time > idle-domain
> -  In the same class priorities are assigned as following:
> -   EDF: early deadline > late deadline
> -   L0 extra-time: lower score > higher score*/
> +/*
> + * Compares two domains in the relation of whether the one is allowed to
> + * interrupt the others execution.
> + * It returns true (!=0) if a switch to the other domain is good.
> + * Current Priority scheme is as follows:
> + *  EDF > L0 (penalty based) extra-time >
> + *  L1 (utilization) extra-time > idle-domain
> + * In the same class priorities are assigned as following:
> + *  EDF: early deadline > late deadline
> + *  L0 extra-time: lower score > higher score
> + */
>  static inline int should_switch(struct vcpu *cur,
>                                 struct vcpu *other,
>                                 s_time_t now)
> @@ -1085,26 +1057,25 @@ static inline int should_switch(struct v
>     cur_inf   = EDOM_INFO(cur);
>     other_inf = EDOM_INFO(other);
>
> -    /* Check whether we need to make an earlier scheduling decision. */
> +    /* Check whether we need to make an earlier scheduling decision */
>     if ( PERIOD_BEGIN(other_inf) <
>          CPU_INFO(other->processor)->current_slice_expires )
>         return 1;
>
> -    /* No timing-based switches need to be taken into account here. */
> +    /* No timing-based switches need to be taken into account here */
>     switch ( get_run_type(cur) )
>     {
>     case DOMAIN_EDF:
> -        /* Do not interrupt a running EDF domain. */
> +        /* Do not interrupt a running EDF domain */
>         return 0;
>     case DOMAIN_EXTRA_PEN:
> -        /* Check whether we also want the L0 ex-q with lower score. */
> +        /* Check whether we also want the L0 ex-q with lower score */
>         return ((other_inf->status & EXTRA_WANT_PEN_Q) &&
>                 (other_inf->score[EXTRA_PEN_Q] <
>                  cur_inf->score[EXTRA_PEN_Q]));
>     case DOMAIN_EXTRA_UTIL:
>         /* Check whether we want the L0 extraq. Don''t
> -         * switch if both domains want L1 extraq.
> -         */
> +         * switch if both domains want L1 extraq. */
>         return !!(other_inf->status & EXTRA_WANT_PEN_Q);
>     case DOMAIN_IDLE:
>         return 1;
> @@ -1118,18 +1089,11 @@ static void sedf_wake(const struct sched
>     s_time_t              now = NOW();
>     struct sedf_vcpu_info* inf = EDOM_INFO(d);
>
> -    PRINT(3, "sedf_wake was called, domain-id
%i.%i\n",d->domain->domain_id,
> -          d->vcpu_id);
> -
>     if ( unlikely(is_idle_vcpu(d)) )
>         return;
>
>     if ( unlikely(__task_on_queue(d)) )
> -    {
> -        PRINT(3,"\tdomain %i.%i is already in some queue\n",
> -              d->domain->domain_id, d->vcpu_id);
>         return;
> -    }
>
>     ASSERT(!sedf_runnable(d));
>     inf->status &= ~SEDF_ASLEEP;
> @@ -1138,28 +1102,25 @@ static void sedf_wake(const struct sched
>
>     if ( unlikely(inf->deadl_abs == 0) )
>     {
> -        /*initial setup of the deadline*/
> +        /* Initial setup of the deadline */
>         inf->deadl_abs = now + inf->slice;
>     }
>
> -    PRINT(3, "waking up domain %i.%i (deadl= %"PRIu64"
period= %"PRIu64
> -          "now= %"PRIu64")\n",
> -          d->domain->domain_id, d->vcpu_id, inf->deadl_abs,
inf->period, now);
> -
>  #ifdef SEDF_STATS
>     inf->block_tot++;
>  #endif
>
>     if ( unlikely(now < PERIOD_BEGIN(inf)) )
>     {
> -        PRINT(4,"extratime unblock\n");
> -        /* unblocking in extra-time! */
> +        /* Unblocking in extra-time! */
>         if ( inf->status & EXTRA_WANT_PEN_Q )
>         {
> -            /*we have a domain that wants compensation
> -              for block penalty and did just block in
> -              its compensation time. Give it another
> -              chance!*/
> +            /*
> +             * We have a domain that wants compensation
> +             * for block penalty and did just block in
> +             * its compensation time. Give it another
> +             * chance!
> +             */
>             extraq_add_sort_update(d, EXTRA_PEN_Q, 0);
>         }
>         extraq_check_add_unblocked(d, 0);
> @@ -1168,8 +1129,7 @@ static void sedf_wake(const struct sched
>     {
>         if ( now < inf->deadl_abs )
>         {
> -            PRINT(4,"short unblocking\n");
> -            /*short blocking*/
> +            /* Short blocking */
>  #ifdef SEDF_STATS
>             inf->short_block_tot++;
>  #endif
> @@ -1179,8 +1139,7 @@ static void sedf_wake(const struct sched
>         }
>         else
>         {
> -            PRINT(4,"long unblocking\n");
> -            /*long unblocking*/
> +            /* Long unblocking */
>  #ifdef SEDF_STATS
>             inf->long_block_tot++;
>  #endif
> @@ -1190,24 +1149,13 @@ static void sedf_wake(const struct sched
>         }
>     }
>
> -    PRINT(3, "woke up domain %i.%i (deadl= %"PRIu64"
period= %"PRIu64
> -          "now= %"PRIu64")\n",
> -          d->domain->domain_id, d->vcpu_id, inf->deadl_abs,
> -          inf->period, now);
> -
>     if ( PERIOD_BEGIN(inf) > now )
> -    {
>         __add_to_waitqueue_sort(d);
> -        PRINT(3,"added to waitq\n");
> -    }
>     else
> -    {
>         __add_to_runqueue_sort(d);
> -        PRINT(3,"added to runq\n");
> -    }
>
>  #ifdef SEDF_STATS
> -    /*do some statistics here...*/
> +    /* Do some statistics here... */
>     if ( inf->block_abs != 0 )
>     {
>         inf->block_time_tot += now - inf->block_abs;
> @@ -1216,12 +1164,14 @@ static void sedf_wake(const struct sched
>     }
>  #endif
>
> -    /*sanity check: make sure each extra-aware domain IS on the util-q!*/
> +    /* Sanity check: make sure each extra-aware domain IS on the util-q!
*/
>     ASSERT(IMPLY(inf->status & EXTRA_AWARE, extraq_on(d,
EXTRA_UTIL_Q)));
>     ASSERT(__task_on_queue(d));
> -    /*check whether the awakened task needs to invoke the do_schedule
> -      routine. Try to avoid unnecessary runs but:
> -      Save approximation: Always switch to scheduler!*/
> +    /*
> +     * Check whether the awakened task needs to invoke the do_schedule
> +     * routine. Try to avoid unnecessary runs but:
> +     * Save approximation: Always switch to scheduler!
> +     */
>     ASSERT(d->processor >= 0);
>     ASSERT(d->processor < nr_cpu_ids);
>     ASSERT(per_cpu(schedule_data, d->processor).curr);
> @@ -1266,7 +1216,7 @@ static void sedf_dump_domain(struct vcpu
>  }
>
>
> -/* dumps all domains on the specified cpu */
> +/* Dumps all domains on the specified cpu */
>  static void sedf_dump_cpu_state(const struct scheduler *ops, int i)
>  {
>     struct list_head      *list, *queue, *tmp;
> @@ -1341,16 +1291,18 @@ static void sedf_dump_cpu_state(const st
>  }
>
>
> -/* Adjusts periods and slices of the domains accordingly to their weights.
*/
> +/* Adjusts periods and slices of the domains accordingly to their weights
*/
>  static int sedf_adjust_weights(struct cpupool *c, int nr_cpus, int *sumw,
s_time_t *sumt)
>  {
>     struct vcpu *p;
>     struct domain      *d;
>     unsigned int        cpu;
>
> -    /* Sum across all weights. Notice that no runq locking is needed
> +    /*
> +     * Sum across all weights. Notice that no runq locking is needed
>      * here: the caller holds sedf_priv_info.lock and we''re not
changing
> -     * anything that is accessed during scheduling. */
> +     * anything that is accessed during scheduling.
> +     */
>     rcu_read_lock(&domlist_read_lock);
>     for_each_domain_in_cpupool( d, c )
>     {
> @@ -1365,11 +1317,14 @@ static int sedf_adjust_weights(struct cp
>             }
>             else
>             {
> -                /*don''t modify domains who don''t have a
weight, but sum
> -                  up the time they need, projected to a WEIGHT_PERIOD,
> -                  so that this time is not given to the weight-driven
> -                  domains*/
> -                /*check for overflows*/
> +                /*
> +                 * Don''t modify domains who don''t have a
weight, but sum
> +                 * up the time they need, projected to a WEIGHT_PERIOD,
> +                 * so that this time is not given to the weight-driven
> +                 *  domains
> +                 */
> +
> +                /* Check for overflows */
>                 ASSERT((WEIGHT_PERIOD < ULONG_MAX)
>                        && (EDOM_INFO(p)->slice_orig <
ULONG_MAX));
>                 sumt[cpu] +> @@ -1380,9 +1335,11 @@ static int
sedf_adjust_weights(struct cp
>     }
>     rcu_read_unlock(&domlist_read_lock);
>
> -    /* Adjust all slices (and periods) to the new weight. Unlike above, we
> +    /*
> +     * Adjust all slices (and periods) to the new weight. Unlike above, we
>      * need to take thr runq lock for the various VCPUs: we''re
modyfing
> -     * slice and period which are referenced during scheduling. */
> +     * slice and period which are referenced during scheduling.
> +     */
>     rcu_read_lock(&domlist_read_lock);
>     for_each_domain_in_cpupool( d, c )
>     {
> @@ -1410,7 +1367,7 @@ static int sedf_adjust_weights(struct cp
>  }
>
>
> -/* set or fetch domain scheduling parameters */
> +/* Set or fetch domain scheduling parameters */
>  static int sedf_adjust(const struct scheduler *ops, struct domain *p,
struct xen_domctl_scheduler_op *op)
>  {
>     struct sedf_priv_info *prv = SEDF_PRIV(ops);
> @@ -1421,23 +1378,22 @@ static int sedf_adjust(const struct sche
>     struct vcpu *v;
>     int rc = 0;
>
> -    PRINT(2,"sedf_adjust was called, domain-id %i new period
%"PRIu64" "
> -          "new slice %"PRIu64"\nlatency %"PRIu64"
extra:%s\n",
> -          p->domain_id, op->u.sedf.period, op->u.sedf.slice,
> -          op->u.sedf.latency,
(op->u.sedf.extratime)?"yes":"no");
> -
> -    /* Serialize against the pluggable scheduler lock to protect from
> +    /*
> +     * Serialize against the pluggable scheduler lock to protect from
>      * concurrent updates. We need to take the runq lock for the VCPUs
>      * as well, since we are touching extraweight, weight, slice and
>      * period. As in sched_credit2.c, runq locks nest inside the
> -     * pluggable scheduler lock. */
> +     * pluggable scheduler lock.
> +     */
>     spin_lock_irqsave(&prv->lock, flags);
>
>     if ( op->cmd == XEN_DOMCTL_SCHEDOP_putinfo )
>     {
> -        /* These are used in sedf_adjust_weights() but have to be
allocated in
> +        /*
> +         * These are used in sedf_adjust_weights() but have to be
allocated in
>          * this function, as we need to avoid nesting
xmem_pool_alloc''s lock
> -         * within our prv->lock. */
> +         * within our prv->lock.
> +         */
>         if ( !sumw || !sumt )
>         {
>             /* Check for errors here, the _getinfo branch doesn''t
care */
> @@ -1445,7 +1401,7 @@ static int sedf_adjust(const struct sche
>             goto out;
>         }
>
> -        /* Check for sane parameters. */
> +        /* Check for sane parameters */
>         if ( !op->u.sedf.period && !op->u.sedf.weight )
>         {
>             rc = -EINVAL;
> @@ -1457,7 +1413,7 @@ static int sedf_adjust(const struct sche
>             if ( (op->u.sedf.extratime & EXTRA_AWARE) &&
>                  (!op->u.sedf.period) )
>             {
> -                /* Weight-driven domains with extratime only. */
> +                /* Weight-driven domains with extratime only */
>                 for_each_vcpu ( p, v )
>                 {
>                     /* (Here and everywhere in the following) IRQs are
already off,
> @@ -1472,7 +1428,7 @@ static int sedf_adjust(const struct sche
>             }
>             else
>             {
> -                /* Weight-driven domains with real-time execution. */
> +                /* Weight-driven domains with real-time execution */
>                 for_each_vcpu ( p, v ) {
>                     vcpu_schedule_lock(v);
>                     EDOM_INFO(v)->weight = op->u.sedf.weight;
> @@ -1495,7 +1451,7 @@ static int sedf_adjust(const struct sche
>                 goto out;
>             }
>
> -            /* Time-driven domains. */
> +            /* Time-driven domains */
>             for_each_vcpu ( p, v )
>             {
>                 vcpu_schedule_lock(v);
> @@ -1545,7 +1501,6 @@ out:
>     xfree(sumt);
>     xfree(sumw);
>
> -    PRINT(2,"sedf_adjust_finished with return code %d\n", rc);
>     return rc;
>  }
>
>
> --
> <<This happens because I choose it to happen!>> (Raistlin
Majere)
> -------------------------------------------------------------------
> Dario Faggioli, http://retis.sssup.it/people/faggioli
> Senior Software Engineer, Citrix Systems R&D Ltd., Cambridge (UK)
> PhD Candidate, ReTiS Lab, Scuola Superiore Sant''Anna, Pisa (Italy)
>
>
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@lists.xensource.com
> http://lists.xensource.com/xen-devel
>

On Thu, Jan 5, 2012 at 3:17 PM, Dario Faggioli <raistlin@linux.it>
wrote:
> sched_sedf.c used o have its own mechanism for producing tracing-alike
> kind of information (domain block, wakeup, etc.). Nowadays, with an even
> not so high number of pCPUs/vCPUs, just trying to enable this makes
> the serial console completely unusable, produces tons of very hard to
> parse and interpreet logging and can easily livelock Dom0. Moreover,
> pretty much the same result this is struggling to get to, is better
> achieved by enabling the scheduler-related tracing events, as
> it is for the other schedulers (say, credit or credit2).
>
> For all these reasons, this removes that machinery completely. While at
> it, check in some cosmetics that harmonize the comments withim themself
> and with the rest of the code base.
>
> Signed-off-by: Dario Faggioli <dario.faggioli@citrix.com>
Looks good -- thanks, Dario.

Acked-by: George Dunlap <george.dunlap@eu.citrix.com>
>
> diff -r efaa28639a71 xen/common/sched_sedf.c
> --- a/xen/common/sched_sedf.c   Wed Jan 04 16:12:44 2012 +0000
> +++ b/xen/common/sched_sedf.c   Thu Jan 05 15:02:30 2012 +0100
> @@ -13,14 +13,6 @@
>  #include <xen/time.h>
>  #include <xen/errno.h>
>
> -/*verbosity settings*/
> -#define SEDFLEVEL 0
> -#define PRINT(_f, _a...)                        \
> -    do {                                        \
> -        if ( (_f) <= SEDFLEVEL )                \
> -            printk(_a );                        \
> -    } while ( 0 )
> -
>  #define SEDF_CPUONLINE(_pool)                                            
\
>     (((_pool) == NULL) ? &cpupool_free_cpus : (_pool)->cpu_valid)
>
> @@ -71,34 +63,35 @@ struct sedf_vcpu_info {
>     struct list_head list;
>     struct list_head extralist[2];
>
> -    /*Parameters for EDF*/
> -    s_time_t  period;  /*=(relative deadline)*/
> -    s_time_t  slice;  /*=worst case execution time*/
> +    /* Parameters for EDF */
> +    s_time_t  period;  /* = relative deadline */
> +    s_time_t  slice;   /* = worst case execution time */
>
> -    /*Advaced Parameters*/
> -    /*Latency Scaling*/
> +    /* Advaced Parameters */
> +
> +    /* Latency Scaling */
>     s_time_t  period_orig;
>     s_time_t  slice_orig;
>     s_time_t  latency;
>
> -    /*status of domain*/
> +    /* Status of domain */
>     int       status;
> -    /*weights for "Scheduling for beginners/ lazy/ etc." ;)*/
> +    /* Weights for "Scheduling for beginners/ lazy/ etc." ;) */
>     short     weight;
>     short     extraweight;
> -    /*Bookkeeping*/
> +    /* Bookkeeping */
>     s_time_t  deadl_abs;
>     s_time_t  sched_start_abs;
>     s_time_t  cputime;
> -    /* times the domain un-/blocked */
> +    /* Times the domain un-/blocked */
>     s_time_t  block_abs;
>     s_time_t  unblock_abs;
>
> -    /*scores for {util, block penalty}-weighted extratime distribution*/
> +    /* Scores for {util, block penalty}-weighted extratime distribution */
>     int   score[2];
>     s_time_t  short_block_lost_tot;
>
> -    /*Statistics*/
> +    /* Statistics */
>     s_time_t  extra_time_tot;
>
>  #ifdef SEDF_STATS
> @@ -165,18 +158,17 @@ static inline void extraq_del(struct vcp
>  {
>     struct list_head *list = EXTRALIST(d,i);
>     ASSERT(extraq_on(d,i));
> -    PRINT(3, "Removing domain %i.%i from L%i extraq\n",
> -          d->domain->domain_id, d->vcpu_id, i);
>     list_del(list);
>     list->next = NULL;
>     ASSERT(!extraq_on(d, i));
>  }
>
> -/* adds a domain to the queue of processes which are aware of extra time.
List
> -   is sorted by score, where a lower score means higher priority for an
extra
> -   slice. It also updates the score, by simply subtracting a fixed value
from
> -   each entry, in order to avoid overflow. The algorithm works by simply
> -   charging each domain that recieved extratime with an inverse of its
weight.
> +/*
> + * Adds a domain to the queue of processes which are aware of extra time.
List
> + * is sorted by score, where a lower score means higher priority for an
extra
> + * slice. It also updates the score, by simply subtracting a fixed value
from
> + * each entry, in order to avoid overflow. The algorithm works by simply
> + * charging each domain that recieved extratime with an inverse of its
weight.
>  */
>  static inline void extraq_add_sort_update(struct vcpu *d, int i, int sub)
>  {
> @@ -185,11 +177,6 @@ static inline void extraq_add_sort_updat
>
>     ASSERT(!extraq_on(d,i));
>
> -    PRINT(3, "Adding domain %i.%i (score= %i, short_pen=
%"PRIi64")"
> -          " to L%i extraq\n",
> -          d->domain->domain_id, d->vcpu_id,
EDOM_INFO(d)->score[i],
> -          EDOM_INFO(d)->short_block_lost_tot, i);
> -
>     /*
>      * Iterate through all elements to find our "hole" and on our
way
>      * update all the other scores.
> @@ -200,25 +187,18 @@ static inline void extraq_add_sort_updat
>         curinf->score[i] -= sub;
>         if ( EDOM_INFO(d)->score[i] < curinf->score[i] )
>             break;
> -        PRINT(4,"\tbehind domain %i.%i (score= %i)\n",
> -              curinf->vcpu->domain->domain_id,
> -              curinf->vcpu->vcpu_id, curinf->score[i]);
>     }
>
> -    /* cur now contains the element, before which we''ll enqueue.
*/
> -    PRINT(3, "\tlist_add to %p\n", cur->prev);
> +    /* cur now contains the element, before which we''ll enqueue
*/
>     list_add(EXTRALIST(d,i),cur->prev);
>
> -    /* Continue updating the extraq. */
> +    /* Continue updating the extraq */
>     if ( (cur != EXTRAQ(d->processor,i)) && sub )
>     {
>         for ( cur = cur->next; cur != EXTRAQ(d->processor,i); cur =
cur->next )
>         {
>             curinf = list_entry(cur,struct sedf_vcpu_info, extralist[i]);
>             curinf->score[i] -= sub;
> -            PRINT(4, "\tupdating domain %i.%i (score= %u)\n",
> -                  curinf->vcpu->domain->domain_id,
> -                  curinf->vcpu->vcpu_id, curinf->score[i]);
>         }
>     }
>
> @@ -228,29 +208,14 @@ static inline void extraq_check(struct v
>  {
>     if ( extraq_on(d, EXTRA_UTIL_Q) )
>     {
> -        PRINT(2,"Dom %i.%i is on L1 extraQ\n",
> -              d->domain->domain_id, d->vcpu_id);
> -
>         if ( !(EDOM_INFO(d)->status & EXTRA_AWARE) &&
>              !extra_runs(EDOM_INFO(d)) )
> -        {
>             extraq_del(d, EXTRA_UTIL_Q);
> -            PRINT(2,"Removed dom %i.%i from L1 extraQ\n",
> -                  d->domain->domain_id, d->vcpu_id);
> -        }
>     }
>     else
>     {
> -        PRINT(2, "Dom %i.%i is NOT on L1 extraQ\n",
> -              d->domain->domain_id,
> -              d->vcpu_id);
> -
>         if ( (EDOM_INFO(d)->status & EXTRA_AWARE) &&
sedf_runnable(d) )
> -        {
>             extraq_add_sort_update(d, EXTRA_UTIL_Q, 0);
> -            PRINT(2,"Added dom %i.%i to L1 extraQ\n",
> -                  d->domain->domain_id, d->vcpu_id);
> -        }
>     }
>  }
>
> @@ -259,7 +224,7 @@ static inline void extraq_check_add_unbl
>     struct sedf_vcpu_info *inf = EDOM_INFO(d);
>
>     if ( inf->status & EXTRA_AWARE )
> -        /* Put on the weighted extraq without updating any scores. */
> +        /* Put on the weighted extraq without updating any scores */
>         extraq_add_sort_update(d, EXTRA_UTIL_Q, 0);
>  }
>
> @@ -272,8 +237,6 @@ static inline void __del_from_queue(stru
>  {
>     struct list_head *list = LIST(d);
>     ASSERT(__task_on_queue(d));
> -    PRINT(3,"Removing domain %i.%i (bop= %"PRIu64") from
runq/waitq\n",
> -          d->domain->domain_id, d->vcpu_id,
PERIOD_BEGIN(EDOM_INFO(d)));
>     list_del(list);
>     list->next = NULL;
>     ASSERT(!__task_on_queue(d));
> @@ -286,13 +249,12 @@ static inline void list_insert_sort(
>  {
>     struct list_head     *cur;
>
> -    /* Iterate through all elements to find our "hole". */
> +    /* Iterate through all elements to find our "hole" */
>     list_for_each( cur, list )
>         if ( comp(element, cur) < 0 )
>             break;
>
> -    /* cur now contains the element, before which we''ll enqueue.
*/
> -    PRINT(3,"\tlist_add to %p\n",cur->prev);
> +    /* cur now contains the element, before which we''ll enqueue
*/
>     list_add(element, cur->prev);
>  }
>
> @@ -310,30 +272,28 @@ static int name##_comp(struct list_head*
>         return 1;                                                       \
>  }
>
> -/* adds a domain to the queue of processes which wait for the beginning of
the
> -   next period; this list is therefore sortet by this time, which is
simply
> -   absol. deadline - period
> +/*
> + * Adds a domain to the queue of processes which wait for the beginning of
the
> + * next period; this list is therefore sortet by this time, which is
simply
> + * absol. deadline - period.
>  */
>  DOMAIN_COMPARER(waitq, list, PERIOD_BEGIN(d1), PERIOD_BEGIN(d2));
>  static inline void __add_to_waitqueue_sort(struct vcpu *v)
>  {
>     ASSERT(!__task_on_queue(v));
> -    PRINT(3,"Adding domain %i.%i (bop= %"PRIu64") to
waitq\n",
> -          v->domain->domain_id, v->vcpu_id,
PERIOD_BEGIN(EDOM_INFO(v)));
>     list_insert_sort(WAITQ(v->processor), LIST(v), waitq_comp);
>     ASSERT(__task_on_queue(v));
>  }
>
> -/* adds a domain to the queue of processes which have started their
current
> -   period and are runnable (i.e. not blocked, dieing,...). The first
element
> -   on this list is running on the processor, if the list is empty the idle
> -   task will run. As we are implementing EDF, this list is sorted by
deadlines.
> +/*
> + * Adds a domain to the queue of processes which have started their
current
> + * period and are runnable (i.e. not blocked, dieing,...). The first
element
> + * on this list is running on the processor, if the list is empty the idle
> + * task will run. As we are implementing EDF, this list is sorted by
deadlines.
>  */
>  DOMAIN_COMPARER(runq, list, d1->deadl_abs, d2->deadl_abs);
>  static inline void __add_to_runqueue_sort(struct vcpu *v)
>  {
> -    PRINT(3,"Adding domain %i.%i (deadl= %"PRIu64") to
runq\n",
> -          v->domain->domain_id, v->vcpu_id,
EDOM_INFO(v)->deadl_abs);
>     list_insert_sort(RUNQ(v->processor), LIST(v), runq_comp);
>  }
>
> @@ -361,12 +321,12 @@ static void *sedf_alloc_vdata(const stru
>
>     inf->vcpu = v;
>
> -    /* Every VCPU gets an equal share of extratime by default. */
> +    /* Every VCPU gets an equal share of extratime by default */
>     inf->deadl_abs   = 0;
>     inf->latency     = 0;
>     inf->status      = EXTRA_AWARE | SEDF_ASLEEP;
>     inf->extraweight = 1;
> -    /* Upon creation all domain are best-effort. */
> +    /* Upon creation all domain are best-effort */
>     inf->period      = WEIGHT_PERIOD;
>     inf->slice       = 0;
>
> @@ -450,21 +410,19 @@ static void desched_edf_dom(s_time_t now
>  {
>     struct sedf_vcpu_info* inf = EDOM_INFO(d);
>
> -    /* Current domain is running in real time mode. */
> +    /* Current domain is running in real time mode */
>     ASSERT(__task_on_queue(d));
>
> -    /* Update the domain''s cputime. */
> +    /* Update the domain''s cputime */
>     inf->cputime += now - inf->sched_start_abs;
>
> -    /*
> -     * Scheduling decisions which don''t remove the running domain
from the
> -     * runq.
> -     */
> +    /* Scheduling decisions which don''t remove the running domain
from
> +     * the runq */
>     if ( (inf->cputime < inf->slice) && sedf_runnable(d) )
>         return;
>
>     __del_from_queue(d);
> -
> +
>     /*
>      * Manage bookkeeping (i.e. calculate next deadline, memorise
>      * overrun-time of slice) of finished domains.
> @@ -475,30 +433,30 @@ static void desched_edf_dom(s_time_t now
>
>         if ( inf->period < inf->period_orig )
>         {
> -            /* This domain runs in latency scaling or burst mode. */
> +            /* This domain runs in latency scaling or burst mode */
>             inf->period *= 2;
>             inf->slice  *= 2;
>             if ( (inf->period > inf->period_orig) ||
>                  (inf->slice > inf->slice_orig) )
>             {
> -                /* Reset slice and period. */
> +                /* Reset slice and period */
>                 inf->period = inf->period_orig;
>                 inf->slice = inf->slice_orig;
>             }
>         }
>
> -        /* Set next deadline. */
> +        /* Set next deadline */
>         inf->deadl_abs += inf->period;
>     }
>
> -    /* Add a runnable domain to the waitqueue. */
> +    /* Add a runnable domain to the waitqueue */
>     if ( sedf_runnable(d) )
>     {
>         __add_to_waitqueue_sort(d);
>     }
>     else
>     {
> -        /* We have a blocked realtime task -> remove it from exqs too.
*/
> +        /* We have a blocked realtime task -> remove it from exqs too
*/
>         if ( extraq_on(d, EXTRA_PEN_Q) )
>             extraq_del(d, EXTRA_PEN_Q);
>         if ( extraq_on(d, EXTRA_UTIL_Q) )
> @@ -518,8 +476,6 @@ static void update_queues(
>     struct list_head     *cur, *tmp;
>     struct sedf_vcpu_info *curinf;
>
> -    PRINT(3,"Updating waitq..\n");
> -
>     /*
>      * Check for the first elements of the waitqueue, whether their
>      * next period has already started.
> @@ -527,41 +483,32 @@ static void update_queues(
>     list_for_each_safe ( cur, tmp, waitq )
>     {
>         curinf = list_entry(cur, struct sedf_vcpu_info, list);
> -        PRINT(4,"\tLooking @ dom %i.%i\n",
> -              curinf->vcpu->domain->domain_id,
curinf->vcpu->vcpu_id);
>         if ( PERIOD_BEGIN(curinf) > now )
>             break;
>         __del_from_queue(curinf->vcpu);
>         __add_to_runqueue_sort(curinf->vcpu);
>     }
>
> -    PRINT(3,"Updating runq..\n");
> -
> -    /* Process the runq, find domains that are on the runq that
shouldn''t. */
> +    /* Process the runq, find domains that are on the runq that
shouldn''t */
>     list_for_each_safe ( cur, tmp, runq )
>     {
>         curinf = list_entry(cur,struct sedf_vcpu_info,list);
> -        PRINT(4,"\tLooking @ dom %i.%i\n",
> -              curinf->vcpu->domain->domain_id,
curinf->vcpu->vcpu_id);
>
>         if ( unlikely(curinf->slice == 0) )
>         {
> -            /* Ignore domains with empty slice. */
> -            PRINT(4,"\tUpdating zero-slice domain %i.%i\n",
> -                  curinf->vcpu->domain->domain_id,
> -                  curinf->vcpu->vcpu_id);
> +            /* Ignore domains with empty slice */
>             __del_from_queue(curinf->vcpu);
>
> -            /* Move them to their next period. */
> +            /* Move them to their next period */
>             curinf->deadl_abs += curinf->period;
>
> -            /* Ensure that the start of the next period is in the future.
*/
> +            /* Ensure that the start of the next period is in the future
*/
>             if ( unlikely(PERIOD_BEGIN(curinf) < now) )
>                 curinf->deadl_abs +>                     (DIV_UP(now
- PERIOD_BEGIN(curinf),
>                             curinf->period)) * curinf->period;
>
> -            /* Put them back into the queue. */
> +            /* Put them back into the queue */
>             __add_to_waitqueue_sort(curinf->vcpu);
>         }
>         else if ( unlikely((curinf->deadl_abs < now) ||
> @@ -571,18 +518,18 @@ static void update_queues(
>              * We missed the deadline or the slice was already finished.
>              * Might hapen because of dom_adj.
>              */
> -            PRINT(4,"\tDomain %i.%i exceeded it''s
deadline/"
> -                  "slice (%"PRIu64" / %"PRIu64")
now: %"PRIu64
> -                  " cputime: %"PRIu64"\n",
> -                  curinf->vcpu->domain->domain_id,
> -                  curinf->vcpu->vcpu_id,
> -                  curinf->deadl_abs, curinf->slice, now,
> -                  curinf->cputime);
> +            printk("\tDomain %i.%i exceeded it''s
deadline/"
> +                   "slice (%"PRIu64" / %"PRIu64")
now: %"PRIu64
> +                   " cputime: %"PRIu64"\n",
> +                   curinf->vcpu->domain->domain_id,
> +                   curinf->vcpu->vcpu_id,
> +                   curinf->deadl_abs, curinf->slice, now,
> +                   curinf->cputime);
>             __del_from_queue(curinf->vcpu);
>
> -            /* Common case: we miss one period. */
> +            /* Common case: we miss one period */
>             curinf->deadl_abs += curinf->period;
> -
> +
>             /*
>              * If we are still behind: modulo arithmetic, force deadline
>              * to be in future and aligned to period borders.
> @@ -593,7 +540,7 @@ static void update_queues(
>                            curinf->period) * curinf->period;
>             ASSERT(curinf->deadl_abs >= now);
>
> -            /* Give a fresh slice. */
> +            /* Give a fresh slice */
>             curinf->cputime = 0;
>             if ( PERIOD_BEGIN(curinf) > now )
>                 __add_to_waitqueue_sort(curinf->vcpu);
> @@ -603,17 +550,17 @@ static void update_queues(
>         else
>             break;
>     }
> -
> -    PRINT(3,"done updating the queues\n");
>  }
>
>
> -/* removes a domain from the head of the according extraQ and
> -   requeues it at a specified position:
> -     round-robin extratime: end of extraQ
> -     weighted ext.: insert in sorted list by score
> -   if the domain is blocked / has regained its short-block-loss
> -   time it is not put on any queue */
> +/*
> + * removes a domain from the head of the according extraQ and
> + * requeues it at a specified position:
> + *   round-robin extratime: end of extraQ
> + *   weighted ext.: insert in sorted list by score
> + * if the domain is blocked / has regained its short-block-loss
> + * time it is not put on any queue.
> + */
>  static void desched_extra_dom(s_time_t now, struct vcpu *d)
>  {
>     struct sedf_vcpu_info *inf = EDOM_INFO(d);
> @@ -622,29 +569,25 @@ static void desched_extra_dom(s_time_t n
>
>     ASSERT(extraq_on(d, i));
>
> -    /* Unset all running flags. */
> +    /* Unset all running flags */
>     inf->status  &= ~(EXTRA_RUN_PEN | EXTRA_RUN_UTIL);
> -    /* Fresh slice for the next run. */
> +    /* Fresh slice for the next run */
>     inf->cputime = 0;
> -    /* Accumulate total extratime. */
> +    /* Accumulate total extratime */
>     inf->extra_time_tot += now - inf->sched_start_abs;
>     /* Remove extradomain from head of the queue. */
>     extraq_del(d, i);
>
> -    /* Update the score. */
> +    /* Update the score */
>     oldscore = inf->score[i];
>     if ( i == EXTRA_PEN_Q )
>     {
> -        /*domain was running in L0 extraq*/
> -        /*reduce block lost, probably more sophistication here!*/
> +        /* Domain was running in L0 extraq */
> +        /* reduce block lost, probably more sophistication here!*/
>         /*inf->short_block_lost_tot -= EXTRA_QUANTUM;*/
>         inf->short_block_lost_tot -= now - inf->sched_start_abs;
> -        PRINT(3,"Domain %i.%i: Short_block_loss:
%"PRIi64"\n",
> -              inf->vcpu->domain->domain_id,
inf->vcpu->vcpu_id,
> -              inf->short_block_lost_tot);
>  #if 0
> -        /*
> -         * KAF: If we don''t exit short-blocking state at this
point
> +        /* KAF: If we don''t exit short-blocking state at this
point
>          * domain0 can steal all CPU for up to 10 seconds before
>          * scheduling settles down (when competing against another
>          * CPU-bound domain). Doing this seems to make things behave
> @@ -653,51 +596,59 @@ static void desched_extra_dom(s_time_t n
>         if ( inf->short_block_lost_tot <= 0 )
>  #endif
>         {
> -            PRINT(4,"Domain %i.%i compensated short block
loss!\n",
> -                  inf->vcpu->domain->domain_id,
inf->vcpu->vcpu_id);
> -            /*we have (over-)compensated our block penalty*/
> +            /* We have (over-)compensated our block penalty */
>             inf->short_block_lost_tot = 0;
> -            /*we don''t want a place on the penalty queue
anymore!*/
> +            /* We don''t want a place on the penalty queue
anymore! */
>             inf->status &= ~EXTRA_WANT_PEN_Q;
>             goto check_extra_queues;
>         }
>
> -        /*we have to go again for another try in the block-extraq,
> -          the score is not used incremantally here, as this is
> -          already done by recalculating the block_lost*/
> +        /*
> +         * We have to go again for another try in the block-extraq,
> +         * the score is not used incremantally here, as this is
> +         * already done by recalculating the block_lost
> +         */
>         inf->score[EXTRA_PEN_Q] = (inf->period << 10) /
>             inf->short_block_lost_tot;
>         oldscore = 0;
>     }
>     else
>     {
> -        /*domain was running in L1 extraq => score is inverse of
> -          utilization and is used somewhat incremental!*/
> +        /*
> +         * Domain was running in L1 extraq => score is inverse of
> +         * utilization and is used somewhat incremental!
> +         */
>         if ( !inf->extraweight )
> -            /*NB: use fixed point arithmetic with 10 bits*/
> +        {
> +            /* NB: use fixed point arithmetic with 10 bits */
>             inf->score[EXTRA_UTIL_Q] = (inf->period << 10) /
>                 inf->slice;
> +        }
>         else
> -            /*conversion between realtime utilisation and extrawieght:
> -              full (ie 100%) utilization is equivalent to 128
extraweight*/
> +        {
> +            /*
> +             * Conversion between realtime utilisation and extrawieght:
> +             * full (ie 100%) utilization is equivalent to 128 extraweight
> +             */
>             inf->score[EXTRA_UTIL_Q] = (1<<17) /
inf->extraweight;
> +        }
>     }
>
>  check_extra_queues:
> -    /* Adding a runnable domain to the right queue and removing blocked
ones*/
> +    /* Adding a runnable domain to the right queue and removing blocked
ones */
>     if ( sedf_runnable(d) )
>     {
> -        /*add according to score: weighted round robin*/
> +        /* Add according to score: weighted round robin */
>         if (((inf->status & EXTRA_AWARE) && (i ==
EXTRA_UTIL_Q)) ||
>             ((inf->status & EXTRA_WANT_PEN_Q) && (i ==
EXTRA_PEN_Q)))
>             extraq_add_sort_update(d, i, oldscore);
>     }
>     else
>     {
> -        /*remove this blocked domain from the waitq!*/
> +        /* Remove this blocked domain from the waitq! */
>         __del_from_queue(d);
> -        /*make sure that we remove a blocked domain from the other
> -          extraq too*/
> +        /* Make sure that we remove a blocked domain from the other
> +         * extraq too. */
>         if ( i == EXTRA_PEN_Q )
>         {
>             if ( extraq_on(d, EXTRA_UTIL_Q) )
> @@ -729,8 +680,10 @@ static struct task_slice sedf_do_extra_s
>
>     if ( !list_empty(extraq[EXTRA_PEN_Q]) )
>     {
> -        /*we still have elements on the level 0 extraq
> -          => let those run first!*/
> +        /*
> +         * We still have elements on the level 0 extraq
> +         * => let those run first!
> +         */
>         runinf   = list_entry(extraq[EXTRA_PEN_Q]->next,
>                               struct sedf_vcpu_info,
extralist[EXTRA_PEN_Q]);
>         runinf->status |= EXTRA_RUN_PEN;
> @@ -744,7 +697,7 @@ static struct task_slice sedf_do_extra_s
>     {
>         if ( !list_empty(extraq[EXTRA_UTIL_Q]) )
>         {
> -            /*use elements from the normal extraqueue*/
> +            /* Use elements from the normal extraqueue */
>             runinf   = list_entry(extraq[EXTRA_UTIL_Q]->next,
>                                   struct sedf_vcpu_info,
>                                   extralist[EXTRA_UTIL_Q]);
> @@ -794,11 +747,13 @@ static void sedf_deinit(const struct sch
>  }
>
>
> -/* Main scheduling function
> -   Reasons for calling this function are:
> -   -timeslice for the current period used up
> -   -domain on waitqueue has started it''s period
> -   -and various others ;) in general: determine which domain to run next*/
> +/*
> + * Main scheduling function
> + * Reasons for calling this function are:
> + * -timeslice for the current period used up
> + * -domain on waitqueue has started it''s period
> + * -and various others ;) in general: determine which domain to run next
> + */
>  static struct task_slice sedf_do_schedule(
>     const struct scheduler *ops, s_time_t now, bool_t
tasklet_work_scheduled)
>  {
> @@ -811,13 +766,15 @@ static struct task_slice sedf_do_schedul
>     struct sedf_vcpu_info *runinf, *waitinf;
>     struct task_slice      ret;
>
> -    /*idle tasks don''t need any of the following stuf*/
> +    /* Idle tasks don''t need any of the following stuf */
>     if ( is_idle_vcpu(current) )
>         goto check_waitq;
> -
> -    /* create local state of the status of the domain, in order to avoid
> -       inconsistent state during scheduling decisions, because data for
> -       vcpu_runnable is not protected by the scheduling lock!*/
> +
> +    /*
> +     * Create local state of the status of the domain, in order to avoid
> +     * inconsistent state during scheduling decisions, because data for
> +     * vcpu_runnable is not protected by the scheduling lock!
> +     */
>     if ( !vcpu_runnable(current) )
>         inf->status |= SEDF_ASLEEP;
>
> @@ -826,7 +783,7 @@ static struct task_slice sedf_do_schedul
>
>     if ( unlikely(extra_runs(inf)) )
>     {
> -        /*special treatment of domains running in extra time*/
> +        /* Special treatment of domains running in extra time */
>         desched_extra_dom(now, current);
>     }
>     else
> @@ -836,10 +793,12 @@ static struct task_slice sedf_do_schedul
>  check_waitq:
>     update_queues(now, runq, waitq);
>
> -    /*now simply pick the first domain from the runqueue, which has the
> -      earliest deadline, because the list is sorted*/
> -
> -    /* Tasklet work (which runs in idle VCPU context) overrides all else.
*/
> +    /*
> +     * Now simply pick the first domain from the runqueue, which has the
> +     * earliest deadline, because the list is sorted
> +     *
> +     * Tasklet work (which runs in idle VCPU context) overrides all else.
> +     */
>     if ( tasklet_work_scheduled ||
>          (list_empty(runq) && list_empty(waitq)) ||
>          unlikely(!cpumask_test_cpu(cpu, SEDF_CPUONLINE(per_cpu(cpupool,
cpu)))) )
> @@ -855,9 +814,11 @@ static struct task_slice sedf_do_schedul
>         {
>             waitinf  = list_entry(waitq->next,
>                                   struct sedf_vcpu_info,list);
> -            /*rerun scheduler, when scheduled domain reaches it''s
> -              end of slice or the first domain from the waitqueue
> -              gets ready*/
> +            /*
> +             * Rerun scheduler, when scheduled domain reaches
it''s
> +             * end of slice or the first domain from the waitqueue
> +             * gets ready.
> +             */
>             ret.time = MIN(now + runinf->slice - runinf->cputime,
>                            PERIOD_BEGIN(waitinf)) - now;
>         }
> @@ -869,14 +830,18 @@ static struct task_slice sedf_do_schedul
>     else
>     {
>         waitinf  = list_entry(waitq->next,struct sedf_vcpu_info, list);
> -        /*we could not find any suitable domain
> -          => look for domains that are aware of extratime*/
> +        /*
> +         * We could not find any suitable domain
> +         * => look for domains that are aware of extratime
> +         */
>         ret = sedf_do_extra_schedule(now, PERIOD_BEGIN(waitinf),
>                                      extraq, cpu);
>     }
>
> -    /*TODO: Do something USEFUL when this happens and find out, why it
> -      still can happen!!!*/
> +    /*
> +     * TODO: Do something USEFUL when this happens and find out, why it
> +     * still can happen!!!
> +     */
>     if ( ret.time < 0)
>     {
>         printk("Ouch! We are seriously BEHIND schedule!
%"PRIi64"\n",
> @@ -896,9 +861,6 @@ static struct task_slice sedf_do_schedul
>
>  static void sedf_sleep(const struct scheduler *ops, struct vcpu *d)
>  {
> -    PRINT(2,"sedf_sleep was called, domain-id %i.%i\n",
> -          d->domain->domain_id, d->vcpu_id);
> -
>     if ( is_idle_vcpu(d) )
>         return;
>
> @@ -920,7 +882,8 @@ static void sedf_sleep(const struct sche
>  }
>
>
> -/* This function wakes up a domain, i.e. moves them into the waitqueue
> +/*
> + * This function wakes up a domain, i.e. moves them into the waitqueue
>  * things to mention are: admission control is taking place nowhere at
>  * the moment, so we can''t be sure, whether it is safe to wake the
domain
>  * up at all. Anyway, even if it is safe (total cpu usage <=100%) there
are
> @@ -994,27 +957,31 @@ static void sedf_sleep(const struct sche
>  static void unblock_short_extra_support(
>     struct sedf_vcpu_info* inf, s_time_t now)
>  {
> -    /*this unblocking scheme tries to support the domain, by assigning it
> -    a priority in extratime distribution according to the loss of time
> -    in this slice due to blocking*/
> +    /*
> +     * This unblocking scheme tries to support the domain, by assigning it
> +     * a priority in extratime distribution according to the loss of time
> +     * in this slice due to blocking
> +     */
>     s_time_t pen;
>
> -    /*no more realtime execution in this period!*/
> +    /* No more realtime execution in this period! */
>     inf->deadl_abs += inf->period;
>     if ( likely(inf->block_abs) )
>     {
> -        //treat blocked time as consumed by the domain*/
> +        /* Treat blocked time as consumed by the domain */
>         /*inf->cputime += now - inf->block_abs;*/
> -        /*penalty is time the domain would have
> -          had if it continued to run */
> +        /*
> +         * Penalty is time the domain would have
> +         * had if it continued to run.
> +         */
>         pen = (inf->slice - inf->cputime);
>         if ( pen < 0 )
>             pen = 0;
> -        /*accumulate all penalties over the periods*/
> +        /* Accumulate all penalties over the periods */
>         /*inf->short_block_lost_tot += pen;*/
> -        /*set penalty to the current value*/
> +        /* Set penalty to the current value */
>         inf->short_block_lost_tot = pen;
> -        /*not sure which one is better.. but seems to work well...*/
> +        /* Not sure which one is better.. but seems to work well... */
>
>         if ( inf->short_block_lost_tot )
>         {
> @@ -1024,28 +991,31 @@ static void unblock_short_extra_support(
>             inf->pen_extra_blocks++;
>  #endif
>             if ( extraq_on(inf->vcpu, EXTRA_PEN_Q) )
> -                /*remove domain for possible resorting!*/
> +                /* Remove domain for possible resorting! */
>                 extraq_del(inf->vcpu, EXTRA_PEN_Q);
>             else
> -                /*remember that we want to be on the penalty q
> -                  so that we can continue when we (un-)block
> -                  in penalty-extratime*/
> +                /*
> +                 * Remember that we want to be on the penalty q
> +                 * so that we can continue when we (un-)block
> +                 * in penalty-extratime
> +                 */
>                 inf->status |= EXTRA_WANT_PEN_Q;
>
> -            /*(re-)add domain to the penalty extraq*/
> +            /* (re-)add domain to the penalty extraq */
>             extraq_add_sort_update(inf->vcpu, EXTRA_PEN_Q, 0);
>         }
>     }
>
> -    /*give it a fresh slice in the next period!*/
> +    /* Give it a fresh slice in the next period! */
>     inf->cputime = 0;
>  }
>
>
>  static void unblock_long_cons_b(struct sedf_vcpu_info* inf,s_time_t now)
>  {
> -    /*Conservative 2b*/
> -    /*Treat the unblocking time as a start of a new period */
> +    /* Conservative 2b */
> +
> +    /* Treat the unblocking time as a start of a new period */
>     inf->deadl_abs = now + inf->period;
>     inf->cputime = 0;
>  }
> @@ -1068,15 +1038,17 @@ static inline int get_run_type(struct vc
>  }
>
>
> -/*Compares two domains in the relation of whether the one is allowed to
> -  interrupt the others execution.
> -  It returns true (!=0) if a switch to the other domain is good.
> -  Current Priority scheme is as follows:
> -   EDF > L0 (penalty based) extra-time >
> -   L1 (utilization) extra-time > idle-domain
> -  In the same class priorities are assigned as following:
> -   EDF: early deadline > late deadline
> -   L0 extra-time: lower score > higher score*/
> +/*
> + * Compares two domains in the relation of whether the one is allowed to
> + * interrupt the others execution.
> + * It returns true (!=0) if a switch to the other domain is good.
> + * Current Priority scheme is as follows:
> + *  EDF > L0 (penalty based) extra-time >
> + *  L1 (utilization) extra-time > idle-domain
> + * In the same class priorities are assigned as following:
> + *  EDF: early deadline > late deadline
> + *  L0 extra-time: lower score > higher score
> + */
>  static inline int should_switch(struct vcpu *cur,
>                                 struct vcpu *other,
>                                 s_time_t now)
> @@ -1085,26 +1057,25 @@ static inline int should_switch(struct v
>     cur_inf   = EDOM_INFO(cur);
>     other_inf = EDOM_INFO(other);
>
> -    /* Check whether we need to make an earlier scheduling decision. */
> +    /* Check whether we need to make an earlier scheduling decision */
>     if ( PERIOD_BEGIN(other_inf) <
>          CPU_INFO(other->processor)->current_slice_expires )
>         return 1;
>
> -    /* No timing-based switches need to be taken into account here. */
> +    /* No timing-based switches need to be taken into account here */
>     switch ( get_run_type(cur) )
>     {
>     case DOMAIN_EDF:
> -        /* Do not interrupt a running EDF domain. */
> +        /* Do not interrupt a running EDF domain */
>         return 0;
>     case DOMAIN_EXTRA_PEN:
> -        /* Check whether we also want the L0 ex-q with lower score. */
> +        /* Check whether we also want the L0 ex-q with lower score */
>         return ((other_inf->status & EXTRA_WANT_PEN_Q) &&
>                 (other_inf->score[EXTRA_PEN_Q] <
>                  cur_inf->score[EXTRA_PEN_Q]));
>     case DOMAIN_EXTRA_UTIL:
>         /* Check whether we want the L0 extraq. Don''t
> -         * switch if both domains want L1 extraq.
> -         */
> +         * switch if both domains want L1 extraq. */
>         return !!(other_inf->status & EXTRA_WANT_PEN_Q);
>     case DOMAIN_IDLE:
>         return 1;
> @@ -1118,18 +1089,11 @@ static void sedf_wake(const struct sched
>     s_time_t              now = NOW();
>     struct sedf_vcpu_info* inf = EDOM_INFO(d);
>
> -    PRINT(3, "sedf_wake was called, domain-id
%i.%i\n",d->domain->domain_id,
> -          d->vcpu_id);
> -
>     if ( unlikely(is_idle_vcpu(d)) )
>         return;
>
>     if ( unlikely(__task_on_queue(d)) )
> -    {
> -        PRINT(3,"\tdomain %i.%i is already in some queue\n",
> -              d->domain->domain_id, d->vcpu_id);
>         return;
> -    }
>
>     ASSERT(!sedf_runnable(d));
>     inf->status &= ~SEDF_ASLEEP;
> @@ -1138,28 +1102,25 @@ static void sedf_wake(const struct sched
>
>     if ( unlikely(inf->deadl_abs == 0) )
>     {
> -        /*initial setup of the deadline*/
> +        /* Initial setup of the deadline */
>         inf->deadl_abs = now + inf->slice;
>     }
>
> -    PRINT(3, "waking up domain %i.%i (deadl= %"PRIu64"
period= %"PRIu64
> -          "now= %"PRIu64")\n",
> -          d->domain->domain_id, d->vcpu_id, inf->deadl_abs,
inf->period, now);
> -
>  #ifdef SEDF_STATS
>     inf->block_tot++;
>  #endif
>
>     if ( unlikely(now < PERIOD_BEGIN(inf)) )
>     {
> -        PRINT(4,"extratime unblock\n");
> -        /* unblocking in extra-time! */
> +        /* Unblocking in extra-time! */
>         if ( inf->status & EXTRA_WANT_PEN_Q )
>         {
> -            /*we have a domain that wants compensation
> -              for block penalty and did just block in
> -              its compensation time. Give it another
> -              chance!*/
> +            /*
> +             * We have a domain that wants compensation
> +             * for block penalty and did just block in
> +             * its compensation time. Give it another
> +             * chance!
> +             */
>             extraq_add_sort_update(d, EXTRA_PEN_Q, 0);
>         }
>         extraq_check_add_unblocked(d, 0);
> @@ -1168,8 +1129,7 @@ static void sedf_wake(const struct sched
>     {
>         if ( now < inf->deadl_abs )
>         {
> -            PRINT(4,"short unblocking\n");
> -            /*short blocking*/
> +            /* Short blocking */
>  #ifdef SEDF_STATS
>             inf->short_block_tot++;
>  #endif
> @@ -1179,8 +1139,7 @@ static void sedf_wake(const struct sched
>         }
>         else
>         {
> -            PRINT(4,"long unblocking\n");
> -            /*long unblocking*/
> +            /* Long unblocking */
>  #ifdef SEDF_STATS
>             inf->long_block_tot++;
>  #endif
> @@ -1190,24 +1149,13 @@ static void sedf_wake(const struct sched
>         }
>     }
>
> -    PRINT(3, "woke up domain %i.%i (deadl= %"PRIu64"
period= %"PRIu64
> -          "now= %"PRIu64")\n",
> -          d->domain->domain_id, d->vcpu_id, inf->deadl_abs,
> -          inf->period, now);
> -
>     if ( PERIOD_BEGIN(inf) > now )
> -    {
>         __add_to_waitqueue_sort(d);
> -        PRINT(3,"added to waitq\n");
> -    }
>     else
> -    {
>         __add_to_runqueue_sort(d);
> -        PRINT(3,"added to runq\n");
> -    }
>
>  #ifdef SEDF_STATS
> -    /*do some statistics here...*/
> +    /* Do some statistics here... */
>     if ( inf->block_abs != 0 )
>     {
>         inf->block_time_tot += now - inf->block_abs;
> @@ -1216,12 +1164,14 @@ static void sedf_wake(const struct sched
>     }
>  #endif
>
> -    /*sanity check: make sure each extra-aware domain IS on the util-q!*/
> +    /* Sanity check: make sure each extra-aware domain IS on the util-q!
*/
>     ASSERT(IMPLY(inf->status & EXTRA_AWARE, extraq_on(d,
EXTRA_UTIL_Q)));
>     ASSERT(__task_on_queue(d));
> -    /*check whether the awakened task needs to invoke the do_schedule
> -      routine. Try to avoid unnecessary runs but:
> -      Save approximation: Always switch to scheduler!*/
> +    /*
> +     * Check whether the awakened task needs to invoke the do_schedule
> +     * routine. Try to avoid unnecessary runs but:
> +     * Save approximation: Always switch to scheduler!
> +     */
>     ASSERT(d->processor >= 0);
>     ASSERT(d->processor < nr_cpu_ids);
>     ASSERT(per_cpu(schedule_data, d->processor).curr);
> @@ -1266,7 +1216,7 @@ static void sedf_dump_domain(struct vcpu
>  }
>
>
> -/* dumps all domains on the specified cpu */
> +/* Dumps all domains on the specified cpu */
>  static void sedf_dump_cpu_state(const struct scheduler *ops, int i)
>  {
>     struct list_head      *list, *queue, *tmp;
> @@ -1341,16 +1291,18 @@ static void sedf_dump_cpu_state(const st
>  }
>
>
> -/* Adjusts periods and slices of the domains accordingly to their weights.
*/
> +/* Adjusts periods and slices of the domains accordingly to their weights
*/
>  static int sedf_adjust_weights(struct cpupool *c, int nr_cpus, int *sumw,
s_time_t *sumt)
>  {
>     struct vcpu *p;
>     struct domain      *d;
>     unsigned int        cpu;
>
> -    /* Sum across all weights. Notice that no runq locking is needed
> +    /*
> +     * Sum across all weights. Notice that no runq locking is needed
>      * here: the caller holds sedf_priv_info.lock and we''re not
changing
> -     * anything that is accessed during scheduling. */
> +     * anything that is accessed during scheduling.
> +     */
>     rcu_read_lock(&domlist_read_lock);
>     for_each_domain_in_cpupool( d, c )
>     {
> @@ -1365,11 +1317,14 @@ static int sedf_adjust_weights(struct cp
>             }
>             else
>             {
> -                /*don''t modify domains who don''t have a
weight, but sum
> -                  up the time they need, projected to a WEIGHT_PERIOD,
> -                  so that this time is not given to the weight-driven
> -                  domains*/
> -                /*check for overflows*/
> +                /*
> +                 * Don''t modify domains who don''t have a
weight, but sum
> +                 * up the time they need, projected to a WEIGHT_PERIOD,
> +                 * so that this time is not given to the weight-driven
> +                 *  domains
> +                 */
> +
> +                /* Check for overflows */
>                 ASSERT((WEIGHT_PERIOD < ULONG_MAX)
>                        && (EDOM_INFO(p)->slice_orig <
ULONG_MAX));
>                 sumt[cpu] +> @@ -1380,9 +1335,11 @@ static int
sedf_adjust_weights(struct cp
>     }
>     rcu_read_unlock(&domlist_read_lock);
>
> -    /* Adjust all slices (and periods) to the new weight. Unlike above, we
> +    /*
> +     * Adjust all slices (and periods) to the new weight. Unlike above, we
>      * need to take thr runq lock for the various VCPUs: we''re
modyfing
> -     * slice and period which are referenced during scheduling. */
> +     * slice and period which are referenced during scheduling.
> +     */
>     rcu_read_lock(&domlist_read_lock);
>     for_each_domain_in_cpupool( d, c )
>     {
> @@ -1410,7 +1367,7 @@ static int sedf_adjust_weights(struct cp
>  }
>
>
> -/* set or fetch domain scheduling parameters */
> +/* Set or fetch domain scheduling parameters */
>  static int sedf_adjust(const struct scheduler *ops, struct domain *p,
struct xen_domctl_scheduler_op *op)
>  {
>     struct sedf_priv_info *prv = SEDF_PRIV(ops);
> @@ -1421,23 +1378,22 @@ static int sedf_adjust(const struct sche
>     struct vcpu *v;
>     int rc = 0;
>
> -    PRINT(2,"sedf_adjust was called, domain-id %i new period
%"PRIu64" "
> -          "new slice %"PRIu64"\nlatency %"PRIu64"
extra:%s\n",
> -          p->domain_id, op->u.sedf.period, op->u.sedf.slice,
> -          op->u.sedf.latency,
(op->u.sedf.extratime)?"yes":"no");
> -
> -    /* Serialize against the pluggable scheduler lock to protect from
> +    /*
> +     * Serialize against the pluggable scheduler lock to protect from
>      * concurrent updates. We need to take the runq lock for the VCPUs
>      * as well, since we are touching extraweight, weight, slice and
>      * period. As in sched_credit2.c, runq locks nest inside the
> -     * pluggable scheduler lock. */
> +     * pluggable scheduler lock.
> +     */
>     spin_lock_irqsave(&prv->lock, flags);
>
>     if ( op->cmd == XEN_DOMCTL_SCHEDOP_putinfo )
>     {
> -        /* These are used in sedf_adjust_weights() but have to be
allocated in
> +        /*
> +         * These are used in sedf_adjust_weights() but have to be
allocated in
>          * this function, as we need to avoid nesting
xmem_pool_alloc''s lock
> -         * within our prv->lock. */
> +         * within our prv->lock.
> +         */
>         if ( !sumw || !sumt )
>         {
>             /* Check for errors here, the _getinfo branch doesn''t
care */
> @@ -1445,7 +1401,7 @@ static int sedf_adjust(const struct sche
>             goto out;
>         }
>
> -        /* Check for sane parameters. */
> +        /* Check for sane parameters */
>         if ( !op->u.sedf.period && !op->u.sedf.weight )
>         {
>             rc = -EINVAL;
> @@ -1457,7 +1413,7 @@ static int sedf_adjust(const struct sche
>             if ( (op->u.sedf.extratime & EXTRA_AWARE) &&
>                  (!op->u.sedf.period) )
>             {
> -                /* Weight-driven domains with extratime only. */
> +                /* Weight-driven domains with extratime only */
>                 for_each_vcpu ( p, v )
>                 {
>                     /* (Here and everywhere in the following) IRQs are
already off,
> @@ -1472,7 +1428,7 @@ static int sedf_adjust(const struct sche
>             }
>             else
>             {
> -                /* Weight-driven domains with real-time execution. */
> +                /* Weight-driven domains with real-time execution */
>                 for_each_vcpu ( p, v ) {
>                     vcpu_schedule_lock(v);
>                     EDOM_INFO(v)->weight = op->u.sedf.weight;
> @@ -1495,7 +1451,7 @@ static int sedf_adjust(const struct sche
>                 goto out;
>             }
>
> -            /* Time-driven domains. */
> +            /* Time-driven domains */
>             for_each_vcpu ( p, v )
>             {
>                 vcpu_schedule_lock(v);
> @@ -1545,7 +1501,6 @@ out:
>     xfree(sumt);
>     xfree(sumw);
>
> -    PRINT(2,"sedf_adjust_finished with return code %d\n", rc);
>     return rc;
>  }
>
>
> --
> <<This happens because I choose it to happen!>> (Raistlin
Majere)
> -------------------------------------------------------------------
> Dario Faggioli, http://retis.sssup.it/people/faggioli
> Senior Software Engineer, Citrix Systems R&D Ltd., Cambridge (UK)
> PhD Candidate, ReTiS Lab, Scuola Superiore Sant''Anna, Pisa (Italy)
>
>
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@lists.xensource.com
> http://lists.xensource.com/xen-devel
>

On Mon, 2012-01-09 at 10:46 +0000, George Dunlap wrote:
> > Signed-off-by: Dario Faggioli <dario.faggioli@citrix.com>
> 
> Looks good -- thanks, Dario.
> 
> Acked-by: George Dunlap <george.dunlap@eu.citrix.com>
> 
Keir, ping. :-)

Dario

-- 
<<This happens because I choose it to happen!>> (Raistlin Majere)
-------------------------------------------------------------------
Dario Faggioli, http://retis.sssup.it/people/faggioli
Senior Software Engineer, Citrix Systems R&D Ltd., Cambridge (UK)
PhD Candidate, ReTiS Lab, Scuola Superiore Sant''Anna, Pisa (Italy)



_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xensource.com
http://lists.xensource.com/xen-devel

On 18/01/2012 08:59, "Dario Faggioli" <raistlin@linux.it> wrote:
> On Mon, 2012-01-09 at 10:46 +0000, George Dunlap wrote:
>>> Signed-off-by: Dario Faggioli <dario.faggioli@citrix.com>
>> 
>> Looks good -- thanks, Dario.
>> 
>> Acked-by: George Dunlap <george.dunlap@eu.citrix.com>
>> 
> Keir, ping. :-)
Already applied xen-unstable:24512.
> Dario

On Wed, 2012-01-18 at 09:30 +0000, Keir Fraser wrote:
> > Keir, ping. :-)
> 
> Already applied xen-unstable:24512.
> 
Oops! Sorry then, I didn''t notice... :-P

Thanks,
Dario

-- 
<<This happens because I choose it to happen!>> (Raistlin Majere)
-------------------------------------------------------------------
Dario Faggioli, http://retis.sssup.it/people/faggioli
Senior Software Engineer, Citrix Systems R&D Ltd., Cambridge (UK)
PhD Candidate, ReTiS Lab, Scuola Superiore Sant''Anna, Pisa (Italy)



_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xensource.com
http://lists.xensource.com/xen-devel