[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

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



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@xxxxxxxx> 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@xxxxxxxxxx>
>
> 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@xxxxxxxxxxxxxxxxxxx
> http://lists.xensource.com/xen-devel
>

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


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.