|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-changelog] [xen master] credit2: use unique names
commit 6af4342276458be5ad8abc86dbf7e9ce680dad5e
Author: Juergen Gross <juergen.gross@xxxxxxxxxxxxxx>
AuthorDate: Wed May 7 16:35:24 2014 +0200
Commit: Jan Beulich <jbeulich@xxxxxxxx>
CommitDate: Wed May 7 16:35:24 2014 +0200
credit2: use unique names
Avoid name duplicated with the credit scheduler. This makes live easier when
debugging with tools like cscope or crash.
Signed-off-by: Juergen Gross <juergen.gross@xxxxxxxxxxxxxx>
Acked-by: Dario Faggioli <dario.faggioli@xxxxxxxxxx>
Reviewed-by: George Dunlap <george.dunlap@xxxxxxxxxxxxx>
---
xen/common/sched_credit2.c | 474 ++++++++++++++++++++++----------------------
1 files changed, 237 insertions(+), 237 deletions(-)
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 97f4049..1ca521b 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -3,7 +3,7 @@
* (C) 2009 - George Dunlap - Citrix Systems R&D UK, Ltd
****************************************************************************
*
- * File: common/csched_credit2.c
+ * File: common/sched_credit2.c
* Author: George Dunlap
*
* Description: Credit-based SMP CPU scheduler
@@ -108,29 +108,29 @@
* Basic constants
*/
/* Default weight: How much a new domain starts with */
-#define CSCHED_DEFAULT_WEIGHT 256
+#define CSCHED2_DEFAULT_WEIGHT 256
/* Min timer: Minimum length a timer will be set, to
* achieve efficiency */
-#define CSCHED_MIN_TIMER MICROSECS(500)
+#define CSCHED2_MIN_TIMER MICROSECS(500)
/* Amount of credit VMs begin with, and are reset to.
* ATM, set so that highest-weight VMs can only run for 10ms
* before a reset event. */
-#define CSCHED_CREDIT_INIT MILLISECS(10)
+#define CSCHED2_CREDIT_INIT MILLISECS(10)
/* Carryover: How much "extra" credit may be carried over after
* a reset. */
-#define CSCHED_CARRYOVER_MAX CSCHED_MIN_TIMER
+#define CSCHED2_CARRYOVER_MAX CSCHED2_MIN_TIMER
/* Stickiness: Cross-L2 migration resistance. Should be less than
* MIN_TIMER. */
-#define CSCHED_MIGRATE_RESIST ((opt_migrate_resist)*MICROSECS(1))
+#define CSCHED2_MIGRATE_RESIST ((opt_migrate_resist)*MICROSECS(1))
/* How much to "compensate" a vcpu for L2 migration */
-#define CSCHED_MIGRATE_COMPENSATION MICROSECS(50)
+#define CSCHED2_MIGRATE_COMPENSATION MICROSECS(50)
/* Reset: Value below which credit will be reset. */
-#define CSCHED_CREDIT_RESET 0
+#define CSCHED2_CREDIT_RESET 0
/* Max timer: Maximum time a guest can be run for. */
-#define CSCHED_MAX_TIMER MILLISECS(2)
+#define CSCHED2_MAX_TIMER MILLISECS(2)
-#define CSCHED_IDLE_CREDIT (-(1<<30))
+#define CSCHED2_IDLE_CREDIT (-(1<<30))
/*
* Flags
@@ -138,8 +138,8 @@
/* CSFLAG_scheduled: Is this vcpu either running on, or context-switching off,
* a physical cpu?
* + Accessed only with runqueue lock held
- * + Set when chosen as next in csched_schedule().
- * + Cleared after context switch has been saved in csched_context_saved()
+ * + Set when chosen as next in csched2_schedule().
+ * + Cleared after context switch has been saved in csched2_context_saved()
* + Checked in vcpu_wake to see if we can add to the runqueue, or if we should
* set CSFLAG_delayed_runq_add
* + Checked to be false in runq_insert.
@@ -148,9 +148,9 @@
#define CSFLAG_scheduled (1<<__CSFLAG_scheduled)
/* CSFLAG_delayed_runq_add: Do we need to add this to the runqueue once it'd
done
* being context switched out?
- * + Set when scheduling out in csched_schedule() if prev is runnable
- * + Set in csched_vcpu_wake if it finds CSFLAG_scheduled set
- * + Read in csched_context_saved(). If set, it adds prev to the runqueue and
+ * + Set when scheduling out in csched2_schedule() if prev is runnable
+ * + Set in csched2_vcpu_wake if it finds CSFLAG_scheduled set
+ * + Read in csched2_context_saved(). If set, it adds prev to the runqueue and
* clears the bit.
*/
#define __CSFLAG_delayed_runq_add 2
@@ -169,14 +169,14 @@ integer_param("sched_credit2_migrate_resist",
opt_migrate_resist);
/*
* Useful macros
*/
-#define CSCHED_PRIV(_ops) \
- ((struct csched_private *)((_ops)->sched_data))
-#define CSCHED_VCPU(_vcpu) ((struct csched_vcpu *) (_vcpu)->sched_priv)
-#define CSCHED_DOM(_dom) ((struct csched_dom *) (_dom)->sched_priv)
+#define CSCHED2_PRIV(_ops) \
+ ((struct csched2_private *)((_ops)->sched_data))
+#define CSCHED2_VCPU(_vcpu) ((struct csched2_vcpu *) (_vcpu)->sched_priv)
+#define CSCHED2_DOM(_dom) ((struct csched2_dom *) (_dom)->sched_priv)
/* CPU to runq_id macro */
-#define c2r(_ops, _cpu) (CSCHED_PRIV(_ops)->runq_map[(_cpu)])
+#define c2r(_ops, _cpu) (CSCHED2_PRIV(_ops)->runq_map[(_cpu)])
/* CPU to runqueue struct macro */
-#define RQD(_ops, _cpu) (&CSCHED_PRIV(_ops)->rqd[c2r(_ops, _cpu)])
+#define RQD(_ops, _cpu) (&CSCHED2_PRIV(_ops)->rqd[c2r(_ops, _cpu)])
/*
* Shifts for load average.
@@ -197,7 +197,7 @@ integer_param("credit2_balance_over",
opt_overload_balance_tolerance);
/*
* Per-runqueue data
*/
-struct csched_runqueue_data {
+struct csched2_runqueue_data {
int id;
spinlock_t lock; /* Lock for this runqueue. */
@@ -218,7 +218,7 @@ struct csched_runqueue_data {
/*
* System-wide private data
*/
-struct csched_private {
+struct csched2_private {
spinlock_t lock;
cpumask_t initialized; /* CPU is initialized for this pool */
@@ -226,7 +226,7 @@ struct csched_private {
int runq_map[NR_CPUS];
cpumask_t active_queues; /* Queues which may have active cpus */
- struct csched_runqueue_data rqd[NR_CPUS];
+ struct csched2_runqueue_data rqd[NR_CPUS];
int load_window_shift;
};
@@ -234,14 +234,14 @@ struct csched_private {
/*
* Virtual CPU
*/
-struct csched_vcpu {
+struct csched2_vcpu {
struct list_head rqd_elem; /* On the runqueue data list */
struct list_head sdom_elem; /* On the domain vcpu list */
struct list_head runq_elem; /* On the runqueue */
- struct csched_runqueue_data *rqd; /* Up-pointer to the runqueue */
+ struct csched2_runqueue_data *rqd; /* Up-pointer to the runqueue */
/* Up-pointers */
- struct csched_dom *sdom;
+ struct csched2_dom *sdom;
struct vcpu *vcpu;
unsigned int weight;
@@ -255,13 +255,13 @@ struct csched_vcpu {
s_time_t load_last_update; /* Last time average was updated */
s_time_t avgload; /* Decaying queue load */
- struct csched_runqueue_data *migrate_rqd; /* Pre-determined rqd to which
to migrate */
+ struct csched2_runqueue_data *migrate_rqd; /* Pre-determined rqd to which
to migrate */
};
/*
* Domain
*/
-struct csched_dom {
+struct csched2_dom {
struct list_head vcpu;
struct list_head sdom_elem;
struct domain *dom;
@@ -278,8 +278,8 @@ struct csched_dom {
*
* FIXME: Do pre-calculated division?
*/
-static void t2c_update(struct csched_runqueue_data *rqd, s_time_t time,
- struct csched_vcpu *svc)
+static void t2c_update(struct csched2_runqueue_data *rqd, s_time_t time,
+ struct csched2_vcpu *svc)
{
uint64_t val = time * rqd->max_weight + svc->residual;
@@ -287,7 +287,7 @@ static void t2c_update(struct csched_runqueue_data *rqd,
s_time_t time,
svc->credit -= val;
}
-static s_time_t c2t(struct csched_runqueue_data *rqd, s_time_t credit, struct
csched_vcpu *svc)
+static s_time_t c2t(struct csched2_runqueue_data *rqd, s_time_t credit, struct
csched2_vcpu *svc)
{
return credit * svc->weight / rqd->max_weight;
}
@@ -297,22 +297,22 @@ static s_time_t c2t(struct csched_runqueue_data *rqd,
s_time_t credit, struct cs
*/
static /*inline*/ int
-__vcpu_on_runq(struct csched_vcpu *svc)
+__vcpu_on_runq(struct csched2_vcpu *svc)
{
return !list_empty(&svc->runq_elem);
}
-static /*inline*/ struct csched_vcpu *
+static /*inline*/ struct csched2_vcpu *
__runq_elem(struct list_head *elem)
{
- return list_entry(elem, struct csched_vcpu, runq_elem);
+ return list_entry(elem, struct csched2_vcpu, runq_elem);
}
static void
__update_runq_load(const struct scheduler *ops,
- struct csched_runqueue_data *rqd, int change, s_time_t now)
+ struct csched2_runqueue_data *rqd, int change, s_time_t now)
{
- struct csched_private *prv = CSCHED_PRIV(ops);
+ struct csched2_private *prv = CSCHED2_PRIV(ops);
s_time_t delta=-1;
now >>= LOADAVG_GRANULARITY_SHIFT;
@@ -354,9 +354,9 @@ __update_runq_load(const struct scheduler *ops,
static void
__update_svc_load(const struct scheduler *ops,
- struct csched_vcpu *svc, int change, s_time_t now)
+ struct csched2_vcpu *svc, int change, s_time_t now)
{
- struct csched_private *prv = CSCHED_PRIV(ops);
+ struct csched2_private *prv = CSCHED2_PRIV(ops);
s_time_t delta=-1;
int vcpu_load;
@@ -399,8 +399,8 @@ __update_svc_load(const struct scheduler *ops,
static void
update_load(const struct scheduler *ops,
- struct csched_runqueue_data *rqd,
- struct csched_vcpu *svc, int change, s_time_t now)
+ struct csched2_runqueue_data *rqd,
+ struct csched2_vcpu *svc, int change, s_time_t now)
{
__update_runq_load(ops, rqd, change, now);
if ( svc )
@@ -408,7 +408,7 @@ update_load(const struct scheduler *ops,
}
static int
-__runq_insert(struct list_head *runq, struct csched_vcpu *svc)
+__runq_insert(struct list_head *runq, struct csched2_vcpu *svc)
{
struct list_head *iter;
int pos = 0;
@@ -423,7 +423,7 @@ __runq_insert(struct list_head *runq, struct csched_vcpu
*svc)
list_for_each( iter, runq )
{
- struct csched_vcpu * iter_svc = __runq_elem(iter);
+ struct csched2_vcpu * iter_svc = __runq_elem(iter);
if ( svc->credit > iter_svc->credit )
{
@@ -439,7 +439,7 @@ __runq_insert(struct list_head *runq, struct csched_vcpu
*svc)
}
static void
-runq_insert(const struct scheduler *ops, unsigned int cpu, struct csched_vcpu
*svc)
+runq_insert(const struct scheduler *ops, unsigned int cpu, struct csched2_vcpu
*svc)
{
struct list_head * runq = &RQD(ops, cpu)->runq;
int pos = 0;
@@ -468,24 +468,24 @@ runq_insert(const struct scheduler *ops, unsigned int
cpu, struct csched_vcpu *s
}
static inline void
-__runq_remove(struct csched_vcpu *svc)
+__runq_remove(struct csched2_vcpu *svc)
{
BUG_ON( !__vcpu_on_runq(svc) );
list_del_init(&svc->runq_elem);
}
-void burn_credits(struct csched_runqueue_data *rqd, struct csched_vcpu *,
s_time_t);
+void burn_credits(struct csched2_runqueue_data *rqd, struct csched2_vcpu *,
s_time_t);
/* Check to see if the item on the runqueue is higher priority than what's
* currently running; if so, wake up the processor */
static /*inline*/ void
-runq_tickle(const struct scheduler *ops, unsigned int cpu, struct csched_vcpu
*new, s_time_t now)
+runq_tickle(const struct scheduler *ops, unsigned int cpu, struct csched2_vcpu
*new, s_time_t now)
{
int i, ipid=-1;
s_time_t lowest=(1<<30);
- struct csched_runqueue_data *rqd = RQD(ops, cpu);
+ struct csched2_runqueue_data *rqd = RQD(ops, cpu);
cpumask_t mask;
- struct csched_vcpu * cur;
+ struct csched2_vcpu * cur;
d2printk("rqt %pv curr %pv\n", new->vcpu, current);
@@ -493,7 +493,7 @@ runq_tickle(const struct scheduler *ops, unsigned int cpu,
struct csched_vcpu *n
BUG_ON(new->rqd != rqd);
/* Look at the cpu it's running on first */
- cur = CSCHED_VCPU(per_cpu(schedule_data, cpu).curr);
+ cur = CSCHED2_VCPU(per_cpu(schedule_data, cpu).curr);
burn_credits(rqd, cur, now);
if ( cur->credit < new->credit )
@@ -520,13 +520,13 @@ runq_tickle(const struct scheduler *ops, unsigned int
cpu, struct csched_vcpu *n
for_each_cpu(i, &mask)
{
- struct csched_vcpu * cur;
+ struct csched2_vcpu * cur;
/* Already looked at this one above */
if ( i == cpu )
continue;
- cur = CSCHED_VCPU(per_cpu(schedule_data, i).curr);
+ cur = CSCHED2_VCPU(per_cpu(schedule_data, i).curr);
BUG_ON(is_idle_vcpu(cur->vcpu));
@@ -555,7 +555,7 @@ runq_tickle(const struct scheduler *ops, unsigned int cpu,
struct csched_vcpu *n
/* Only switch to another processor if the credit difference is greater
* than the migrate resistance */
- if ( ipid == -1 || lowest + CSCHED_MIGRATE_RESIST > new->credit )
+ if ( ipid == -1 || lowest + CSCHED2_MIGRATE_RESIST > new->credit )
goto no_tickle;
tickle:
@@ -581,17 +581,17 @@ no_tickle:
* Credit-related code
*/
static void reset_credit(const struct scheduler *ops, int cpu, s_time_t now,
- struct csched_vcpu *snext)
+ struct csched2_vcpu *snext)
{
- struct csched_runqueue_data *rqd = RQD(ops, cpu);
+ struct csched2_runqueue_data *rqd = RQD(ops, cpu);
struct list_head *iter;
int m;
/*
* Under normal circumstances, snext->credit should never be less
- * than -CSCHED_MIN_TIMER. However, under some circumstances, a
+ * than -CSCHED2_MIN_TIMER. However, under some circumstances, a
* vcpu with low credits may be allowed to run long enough that
- * its credits are actually less than -CSCHED_CREDIT_INIT.
+ * its credits are actually less than -CSCHED2_CREDIT_INIT.
* (Instances have been observed, for example, where a vcpu with
* 200us of credit was allowed to run for 11ms, giving it -10.8ms
* of credit. Thus it was still negative even after the reset.)
@@ -605,15 +605,15 @@ static void reset_credit(const struct scheduler *ops, int
cpu, s_time_t now,
* case.
*/
m = 1;
- if ( snext->credit < -CSCHED_CREDIT_INIT )
- m += (-snext->credit) / CSCHED_CREDIT_INIT;
+ if ( snext->credit < -CSCHED2_CREDIT_INIT )
+ m += (-snext->credit) / CSCHED2_CREDIT_INIT;
list_for_each( iter, &rqd->svc )
{
- struct csched_vcpu * svc;
+ struct csched2_vcpu * svc;
int start_credit;
- svc = list_entry(iter, struct csched_vcpu, rqd_elem);
+ svc = list_entry(iter, struct csched2_vcpu, rqd_elem);
BUG_ON( is_idle_vcpu(svc->vcpu) );
BUG_ON( svc->rqd != rqd );
@@ -623,13 +623,13 @@ static void reset_credit(const struct scheduler *ops, int
cpu, s_time_t now,
/* And add INIT * m, avoiding integer multiplication in the
* common case. */
if ( likely(m==1) )
- svc->credit += CSCHED_CREDIT_INIT;
+ svc->credit += CSCHED2_CREDIT_INIT;
else
- svc->credit += m * CSCHED_CREDIT_INIT;
+ svc->credit += m * CSCHED2_CREDIT_INIT;
/* "Clip" credits to max carryover */
- if ( svc->credit > CSCHED_CREDIT_INIT + CSCHED_CARRYOVER_MAX )
- svc->credit = CSCHED_CREDIT_INIT + CSCHED_CARRYOVER_MAX;
+ if ( svc->credit > CSCHED2_CREDIT_INIT + CSCHED2_CARRYOVER_MAX )
+ svc->credit = CSCHED2_CREDIT_INIT + CSCHED2_CARRYOVER_MAX;
svc->start_time = now;
@@ -653,16 +653,16 @@ static void reset_credit(const struct scheduler *ops, int
cpu, s_time_t now,
/* No need to resort runqueue, as everyone's order should be the same. */
}
-void burn_credits(struct csched_runqueue_data *rqd, struct csched_vcpu *svc,
s_time_t now)
+void burn_credits(struct csched2_runqueue_data *rqd, struct csched2_vcpu *svc,
s_time_t now)
{
s_time_t delta;
/* Assert svc is current */
- ASSERT(svc==CSCHED_VCPU(per_cpu(schedule_data,
svc->vcpu->processor).curr));
+ ASSERT(svc==CSCHED2_VCPU(per_cpu(schedule_data,
svc->vcpu->processor).curr));
if ( is_idle_vcpu(svc->vcpu) )
{
- BUG_ON(svc->credit != CSCHED_IDLE_CREDIT);
+ BUG_ON(svc->credit != CSCHED2_IDLE_CREDIT);
return;
}
@@ -696,7 +696,7 @@ void burn_credits(struct csched_runqueue_data *rqd, struct
csched_vcpu *svc, s_t
}
/* Find the domain with the highest weight. */
-static void update_max_weight(struct csched_runqueue_data *rqd, int new_weight,
+static void update_max_weight(struct csched2_runqueue_data *rqd, int
new_weight,
int old_weight)
{
/* Try to avoid brute-force search:
@@ -717,7 +717,7 @@ static void update_max_weight(struct csched_runqueue_data
*rqd, int new_weight,
list_for_each( iter, &rqd->svc )
{
- struct csched_vcpu * svc = list_entry(iter, struct csched_vcpu,
rqd_elem);
+ struct csched2_vcpu * svc = list_entry(iter, struct csched2_vcpu,
rqd_elem);
if ( svc->weight > max_weight )
max_weight = svc->weight;
@@ -730,13 +730,13 @@ static void update_max_weight(struct csched_runqueue_data
*rqd, int new_weight,
#ifndef NDEBUG
static /*inline*/ void
-__csched_vcpu_check(struct vcpu *vc)
+__csched2_vcpu_check(struct vcpu *vc)
{
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
- struct csched_dom * const sdom = svc->sdom;
+ struct csched2_vcpu * const svc = CSCHED2_VCPU(vc);
+ struct csched2_dom * const sdom = svc->sdom;
BUG_ON( svc->vcpu != vc );
- BUG_ON( sdom != CSCHED_DOM(vc->domain) );
+ BUG_ON( sdom != CSCHED2_DOM(vc->domain) );
if ( sdom )
{
BUG_ON( is_idle_vcpu(vc) );
@@ -747,18 +747,18 @@ __csched_vcpu_check(struct vcpu *vc)
BUG_ON( !is_idle_vcpu(vc) );
}
}
-#define CSCHED_VCPU_CHECK(_vc) (__csched_vcpu_check(_vc))
+#define CSCHED2_VCPU_CHECK(_vc) (__csched2_vcpu_check(_vc))
#else
-#define CSCHED_VCPU_CHECK(_vc)
+#define CSCHED2_VCPU_CHECK(_vc)
#endif
static void *
-csched_alloc_vdata(const struct scheduler *ops, struct vcpu *vc, void *dd)
+csched2_alloc_vdata(const struct scheduler *ops, struct vcpu *vc, void *dd)
{
- struct csched_vcpu *svc;
+ struct csched2_vcpu *svc;
/* Allocate per-VCPU info */
- svc = xzalloc(struct csched_vcpu);
+ svc = xzalloc(struct csched2_vcpu);
if ( svc == NULL )
return NULL;
@@ -774,16 +774,16 @@ csched_alloc_vdata(const struct scheduler *ops, struct
vcpu *vc, void *dd)
{
BUG_ON( svc->sdom == NULL );
- svc->credit = CSCHED_CREDIT_INIT;
+ svc->credit = CSCHED2_CREDIT_INIT;
svc->weight = svc->sdom->weight;
/* Starting load of 50% */
- svc->avgload = 1ULL << (CSCHED_PRIV(ops)->load_window_shift - 1);
+ svc->avgload = 1ULL << (CSCHED2_PRIV(ops)->load_window_shift - 1);
svc->load_last_update = NOW();
}
else
{
BUG_ON( svc->sdom != NULL );
- svc->credit = CSCHED_IDLE_CREDIT;
+ svc->credit = CSCHED2_IDLE_CREDIT;
svc->weight = 0;
}
@@ -794,7 +794,7 @@ csched_alloc_vdata(const struct scheduler *ops, struct vcpu
*vc, void *dd)
/* Add and remove from runqueue assignment (not active run queue) */
static void
-__runq_assign(struct csched_vcpu *svc, struct csched_runqueue_data *rqd)
+__runq_assign(struct csched2_vcpu *svc, struct csched2_runqueue_data *rqd)
{
svc->rqd = rqd;
@@ -824,7 +824,7 @@ __runq_assign(struct csched_vcpu *svc, struct
csched_runqueue_data *rqd)
static void
runq_assign(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched_vcpu *svc = vc->sched_priv;
+ struct csched2_vcpu *svc = vc->sched_priv;
BUG_ON(svc->rqd != NULL);
@@ -832,7 +832,7 @@ runq_assign(const struct scheduler *ops, struct vcpu *vc)
}
static void
-__runq_deassign(struct csched_vcpu *svc)
+__runq_deassign(struct csched2_vcpu *svc)
{
BUG_ON(__vcpu_on_runq(svc));
BUG_ON(test_bit(__CSFLAG_scheduled, &svc->flags));
@@ -849,7 +849,7 @@ __runq_deassign(struct csched_vcpu *svc)
static void
runq_deassign(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched_vcpu *svc = vc->sched_priv;
+ struct csched2_vcpu *svc = vc->sched_priv;
BUG_ON(svc->rqd != RQD(ops, vc->processor));
@@ -857,10 +857,10 @@ runq_deassign(const struct scheduler *ops, struct vcpu
*vc)
}
static void
-csched_vcpu_insert(const struct scheduler *ops, struct vcpu *vc)
+csched2_vcpu_insert(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched_vcpu *svc = vc->sched_priv;
- struct csched_dom * const sdom = svc->sdom;
+ struct csched2_vcpu *svc = vc->sched_priv;
+ struct csched2_dom * const sdom = svc->sdom;
printk("%s: Inserting %pv\n", __func__, vc);
@@ -884,22 +884,22 @@ csched_vcpu_insert(const struct scheduler *ops, struct
vcpu *vc)
sdom->nr_vcpus++;
}
- CSCHED_VCPU_CHECK(vc);
+ CSCHED2_VCPU_CHECK(vc);
}
static void
-csched_free_vdata(const struct scheduler *ops, void *priv)
+csched2_free_vdata(const struct scheduler *ops, void *priv)
{
- struct csched_vcpu *svc = priv;
+ struct csched2_vcpu *svc = priv;
xfree(svc);
}
static void
-csched_vcpu_remove(const struct scheduler *ops, struct vcpu *vc)
+csched2_vcpu_remove(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
- struct csched_dom * const sdom = svc->sdom;
+ struct csched2_vcpu * const svc = CSCHED2_VCPU(vc);
+ struct csched2_dom * const sdom = svc->sdom;
BUG_ON( sdom == NULL );
BUG_ON( !list_empty(&svc->runq_elem) );
@@ -926,9 +926,9 @@ csched_vcpu_remove(const struct scheduler *ops, struct vcpu
*vc)
}
static void
-csched_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc)
+csched2_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
+ struct csched2_vcpu * const svc = CSCHED2_VCPU(vc);
BUG_ON( is_idle_vcpu(vc) );
@@ -945,9 +945,9 @@ csched_vcpu_sleep(const struct scheduler *ops, struct vcpu
*vc)
}
static void
-csched_vcpu_wake(const struct scheduler *ops, struct vcpu *vc)
+csched2_vcpu_wake(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
+ struct csched2_vcpu * const svc = CSCHED2_VCPU(vc);
s_time_t now = 0;
/* Schedule lock should be held at this point. */
@@ -998,9 +998,9 @@ out:
}
static void
-csched_context_saved(const struct scheduler *ops, struct vcpu *vc)
+csched2_context_saved(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
+ struct csched2_vcpu * const svc = CSCHED2_VCPU(vc);
s_time_t now = NOW();
spinlock_t *lock = vcpu_schedule_lock_irq(vc);
@@ -1035,9 +1035,9 @@ csched_context_saved(const struct scheduler *ops, struct
vcpu *vc)
static int
choose_cpu(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched_private *prv = CSCHED_PRIV(ops);
+ struct csched2_private *prv = CSCHED2_PRIV(ops);
int i, min_rqi = -1, new_cpu;
- struct csched_vcpu *svc = CSCHED_VCPU(vc);
+ struct csched2_vcpu *svc = CSCHED2_VCPU(vc);
s_time_t min_avgload;
BUG_ON(cpumask_empty(&prv->active_queues));
@@ -1094,7 +1094,7 @@ choose_cpu(const struct scheduler *ops, struct vcpu *vc)
/* Find the runqueue with the lowest instantaneous load */
for_each_cpu(i, &prv->active_queues)
{
- struct csched_runqueue_data *rqd;
+ struct csched2_runqueue_data *rqd;
s_time_t rqd_avgload;
rqd = prv->rqd + i;
@@ -1143,15 +1143,15 @@ out_up:
typedef struct {
/* NB: Modified by consider() */
s_time_t load_delta;
- struct csched_vcpu * best_push_svc, *best_pull_svc;
+ struct csched2_vcpu * best_push_svc, *best_pull_svc;
/* NB: Read by consider() */
- struct csched_runqueue_data *lrqd;
- struct csched_runqueue_data *orqd;
+ struct csched2_runqueue_data *lrqd;
+ struct csched2_runqueue_data *orqd;
} balance_state_t;
static void consider(balance_state_t *st,
- struct csched_vcpu *push_svc,
- struct csched_vcpu *pull_svc)
+ struct csched2_vcpu *push_svc,
+ struct csched2_vcpu *pull_svc)
{
s_time_t l_load, o_load, delta;
@@ -1184,8 +1184,8 @@ static void consider(balance_state_t *st,
static void migrate(const struct scheduler *ops,
- struct csched_vcpu *svc,
- struct csched_runqueue_data *trqd,
+ struct csched2_vcpu *svc,
+ struct csched2_runqueue_data *trqd,
s_time_t now)
{
if ( test_bit(__CSFLAG_scheduled, &svc->flags) )
@@ -1222,7 +1222,7 @@ static void migrate(const struct scheduler *ops,
static void balance_load(const struct scheduler *ops, int cpu, s_time_t now)
{
- struct csched_private *prv = CSCHED_PRIV(ops);
+ struct csched2_private *prv = CSCHED2_PRIV(ops);
int i, max_delta_rqi = -1;
struct list_head *push_iter, *pull_iter;
@@ -1323,7 +1323,7 @@ retry:
list_for_each( push_iter, &st.lrqd->svc )
{
int inner_load_updated = 0;
- struct csched_vcpu * push_svc = list_entry(push_iter, struct
csched_vcpu, rqd_elem);
+ struct csched2_vcpu * push_svc = list_entry(push_iter, struct
csched2_vcpu, rqd_elem);
__update_svc_load(ops, push_svc, 0, now);
@@ -1333,7 +1333,7 @@ retry:
list_for_each( pull_iter, &st.orqd->svc )
{
- struct csched_vcpu * pull_svc = list_entry(pull_iter, struct
csched_vcpu, rqd_elem);
+ struct csched2_vcpu * pull_svc = list_entry(pull_iter, struct
csched2_vcpu, rqd_elem);
if ( ! inner_load_updated )
{
@@ -1355,7 +1355,7 @@ retry:
list_for_each( pull_iter, &st.orqd->svc )
{
- struct csched_vcpu * pull_svc = list_entry(pull_iter, struct
csched_vcpu, rqd_elem);
+ struct csched2_vcpu * pull_svc = list_entry(pull_iter, struct
csched2_vcpu, rqd_elem);
/* Skip this one if it's already been flagged to migrate */
if ( test_bit(__CSFLAG_runq_migrate_request, &pull_svc->flags) )
@@ -1379,7 +1379,7 @@ out:
}
static int
-csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc)
+csched2_cpu_pick(const struct scheduler *ops, struct vcpu *vc)
{
int new_cpu;
@@ -1389,14 +1389,14 @@ csched_cpu_pick(const struct scheduler *ops, struct
vcpu *vc)
}
static void
-csched_vcpu_migrate(
+csched2_vcpu_migrate(
const struct scheduler *ops, struct vcpu *vc, unsigned int new_cpu)
{
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
- struct csched_runqueue_data *trqd;
+ struct csched2_vcpu * const svc = CSCHED2_VCPU(vc);
+ struct csched2_runqueue_data *trqd;
/* Check if new_cpu is valid */
- BUG_ON(!cpumask_test_cpu(new_cpu, &CSCHED_PRIV(ops)->initialized));
+ BUG_ON(!cpumask_test_cpu(new_cpu, &CSCHED2_PRIV(ops)->initialized));
trqd = RQD(ops, new_cpu);
@@ -1405,16 +1405,16 @@ csched_vcpu_migrate(
}
static int
-csched_dom_cntl(
+csched2_dom_cntl(
const struct scheduler *ops,
struct domain *d,
struct xen_domctl_scheduler_op *op)
{
- struct csched_dom * const sdom = CSCHED_DOM(d);
- struct csched_private *prv = CSCHED_PRIV(ops);
+ struct csched2_dom * const sdom = CSCHED2_DOM(d);
+ struct csched2_private *prv = CSCHED2_PRIV(ops);
unsigned long flags;
- /* Must hold csched_priv lock to read and update sdom,
+ /* Must hold csched2_priv lock to read and update sdom,
* runq lock to update csvcs. */
spin_lock_irqsave(&prv->lock, flags);
@@ -1438,10 +1438,10 @@ csched_dom_cntl(
/* Update weights for vcpus, and max_weight for runqueues on which
they reside */
list_for_each ( iter, &sdom->vcpu )
{
- struct csched_vcpu *svc = list_entry(iter, struct csched_vcpu,
sdom_elem);
+ struct csched2_vcpu *svc = list_entry(iter, struct
csched2_vcpu, sdom_elem);
/* NB: Locking order is important here. Because we grab this
lock here, we
- * must never lock csched_priv.lock if we're holding a
runqueue lock.
+ * must never lock csched2_priv.lock if we're holding a
runqueue lock.
* Also, calling vcpu_schedule_lock() is enough, since IRQs
have already
* been disabled. */
spinlock_t *lock = vcpu_schedule_lock(svc->vcpu);
@@ -1462,12 +1462,12 @@ csched_dom_cntl(
}
static void *
-csched_alloc_domdata(const struct scheduler *ops, struct domain *dom)
+csched2_alloc_domdata(const struct scheduler *ops, struct domain *dom)
{
- struct csched_dom *sdom;
+ struct csched2_dom *sdom;
unsigned long flags;
- sdom = xzalloc(struct csched_dom);
+ sdom = xzalloc(struct csched2_dom);
if ( sdom == NULL )
return NULL;
@@ -1475,29 +1475,29 @@ csched_alloc_domdata(const struct scheduler *ops,
struct domain *dom)
INIT_LIST_HEAD(&sdom->vcpu);
INIT_LIST_HEAD(&sdom->sdom_elem);
sdom->dom = dom;
- sdom->weight = CSCHED_DEFAULT_WEIGHT;
+ sdom->weight = CSCHED2_DEFAULT_WEIGHT;
sdom->nr_vcpus = 0;
- spin_lock_irqsave(&CSCHED_PRIV(ops)->lock, flags);
+ spin_lock_irqsave(&CSCHED2_PRIV(ops)->lock, flags);
- list_add_tail(&sdom->sdom_elem, &CSCHED_PRIV(ops)->sdom);
+ list_add_tail(&sdom->sdom_elem, &CSCHED2_PRIV(ops)->sdom);
- spin_unlock_irqrestore(&CSCHED_PRIV(ops)->lock, flags);
+ spin_unlock_irqrestore(&CSCHED2_PRIV(ops)->lock, flags);
return (void *)sdom;
}
static int
-csched_dom_init(const struct scheduler *ops, struct domain *dom)
+csched2_dom_init(const struct scheduler *ops, struct domain *dom)
{
- struct csched_dom *sdom;
+ struct csched2_dom *sdom;
printk("%s: Initializing domain %d\n", __func__, dom->domain_id);
if ( is_idle_domain(dom) )
return 0;
- sdom = csched_alloc_domdata(ops, dom);
+ sdom = csched2_alloc_domdata(ops, dom);
if ( sdom == NULL )
return -ENOMEM;
@@ -1507,41 +1507,41 @@ csched_dom_init(const struct scheduler *ops, struct
domain *dom)
}
static void
-csched_free_domdata(const struct scheduler *ops, void *data)
+csched2_free_domdata(const struct scheduler *ops, void *data)
{
unsigned long flags;
- struct csched_dom *sdom = data;
+ struct csched2_dom *sdom = data;
- spin_lock_irqsave(&CSCHED_PRIV(ops)->lock, flags);
+ spin_lock_irqsave(&CSCHED2_PRIV(ops)->lock, flags);
list_del_init(&sdom->sdom_elem);
- spin_unlock_irqrestore(&CSCHED_PRIV(ops)->lock, flags);
+ spin_unlock_irqrestore(&CSCHED2_PRIV(ops)->lock, flags);
xfree(data);
}
static void
-csched_dom_destroy(const struct scheduler *ops, struct domain *dom)
+csched2_dom_destroy(const struct scheduler *ops, struct domain *dom)
{
- struct csched_dom *sdom = CSCHED_DOM(dom);
+ struct csched2_dom *sdom = CSCHED2_DOM(dom);
BUG_ON(!list_empty(&sdom->vcpu));
- csched_free_domdata(ops, CSCHED_DOM(dom));
+ csched2_free_domdata(ops, CSCHED2_DOM(dom));
}
/* How long should we let this vcpu run for? */
static s_time_t
-csched_runtime(const struct scheduler *ops, int cpu, struct csched_vcpu *snext)
+csched2_runtime(const struct scheduler *ops, int cpu, struct csched2_vcpu
*snext)
{
s_time_t time;
int rt_credit; /* Proposed runtime measured in credits */
- struct csched_runqueue_data *rqd = RQD(ops, cpu);
+ struct csched2_runqueue_data *rqd = RQD(ops, cpu);
struct list_head *runq = &rqd->runq;
if ( is_idle_vcpu(snext->vcpu) )
- return CSCHED_MAX_TIMER;
+ return CSCHED2_MAX_TIMER;
/* General algorithm:
* 1) Run until snext's credit will be 0
@@ -1557,7 +1557,7 @@ csched_runtime(const struct scheduler *ops, int cpu,
struct csched_vcpu *snext)
* run until your credit ~= his */
if ( ! list_empty(runq) )
{
- struct csched_vcpu *swait = __runq_elem(runq->next);
+ struct csched2_vcpu *swait = __runq_elem(runq->next);
if ( ! is_idle_vcpu(swait->vcpu)
&& swait->credit > 0 )
@@ -1569,7 +1569,7 @@ csched_runtime(const struct scheduler *ops, int cpu,
struct csched_vcpu *snext)
/* The next guy may actually have a higher credit, if we've tried to
* avoid migrating him from a different cpu. DTRT. */
if ( rt_credit <= 0 )
- time = CSCHED_MIN_TIMER;
+ time = CSCHED2_MIN_TIMER;
else
{
/* FIXME: See if we can eliminate this conversion if we know time
@@ -1579,10 +1579,10 @@ csched_runtime(const struct scheduler *ops, int cpu,
struct csched_vcpu *snext)
time = c2t(rqd, rt_credit, snext);
/* Check limits */
- if ( time < CSCHED_MIN_TIMER )
- time = CSCHED_MIN_TIMER;
- else if ( time > CSCHED_MAX_TIMER )
- time = CSCHED_MAX_TIMER;
+ if ( time < CSCHED2_MIN_TIMER )
+ time = CSCHED2_MIN_TIMER;
+ else if ( time > CSCHED2_MAX_TIMER )
+ time = CSCHED2_MAX_TIMER;
}
return time;
@@ -1593,28 +1593,28 @@ void __dump_execstate(void *unused);
/*
* Find a candidate.
*/
-static struct csched_vcpu *
-runq_candidate(struct csched_runqueue_data *rqd,
- struct csched_vcpu *scurr,
+static struct csched2_vcpu *
+runq_candidate(struct csched2_runqueue_data *rqd,
+ struct csched2_vcpu *scurr,
int cpu, s_time_t now)
{
struct list_head *iter;
- struct csched_vcpu *snext = NULL;
+ struct csched2_vcpu *snext = NULL;
/* Default to current if runnable, idle otherwise */
if ( vcpu_runnable(scurr->vcpu) )
snext = scurr;
else
- snext = CSCHED_VCPU(idle_vcpu[cpu]);
+ snext = CSCHED2_VCPU(idle_vcpu[cpu]);
list_for_each( iter, &rqd->runq )
{
- struct csched_vcpu * svc = list_entry(iter, struct csched_vcpu,
runq_elem);
+ struct csched2_vcpu * svc = list_entry(iter, struct csched2_vcpu,
runq_elem);
/* If this is on a different processor, don't pull it unless
- * its credit is at least CSCHED_MIGRATE_RESIST higher. */
+ * its credit is at least CSCHED2_MIGRATE_RESIST higher. */
if ( svc->vcpu->processor != cpu
- && snext->credit + CSCHED_MIGRATE_RESIST > svc->credit )
+ && snext->credit + CSCHED2_MIGRATE_RESIST > svc->credit )
continue;
/* If the next one on the list has more credit than current
@@ -1635,21 +1635,21 @@ runq_candidate(struct csched_runqueue_data *rqd,
* fast for the common case.
*/
static struct task_slice
-csched_schedule(
+csched2_schedule(
const struct scheduler *ops, s_time_t now, bool_t tasklet_work_scheduled)
{
const int cpu = smp_processor_id();
- struct csched_runqueue_data *rqd;
- struct csched_vcpu * const scurr = CSCHED_VCPU(current);
- struct csched_vcpu *snext = NULL;
+ struct csched2_runqueue_data *rqd;
+ struct csched2_vcpu * const scurr = CSCHED2_VCPU(current);
+ struct csched2_vcpu *snext = NULL;
struct task_slice ret;
SCHED_STAT_CRANK(schedule);
- CSCHED_VCPU_CHECK(current);
+ CSCHED2_VCPU_CHECK(current);
d2printk("sc p%d c %pv now %"PRI_stime"\n", cpu, scurr->vcpu, now);
- BUG_ON(!cpumask_test_cpu(cpu, &CSCHED_PRIV(ops)->initialized));
+ BUG_ON(!cpumask_test_cpu(cpu, &CSCHED2_PRIV(ops)->initialized));
rqd = RQD(ops, cpu);
BUG_ON(!cpumask_test_cpu(cpu, &rqd->active));
@@ -1665,9 +1665,9 @@ csched_schedule(
{
int rq;
other_rqi = -2;
- for_each_cpu ( rq, &CSCHED_PRIV(ops)->active_queues )
+ for_each_cpu ( rq, &CSCHED2_PRIV(ops)->active_queues )
{
- if ( scurr->rqd == &CSCHED_PRIV(ops)->rqd[rq] )
+ if ( scurr->rqd == &CSCHED2_PRIV(ops)->rqd[rq] )
{
other_rqi = rq;
break;
@@ -1710,7 +1710,7 @@ csched_schedule(
if ( tasklet_work_scheduled )
{
trace_var(TRC_CSCHED2_SCHED_TASKLET, 0, 0, NULL);
- snext = CSCHED_VCPU(idle_vcpu[cpu]);
+ snext = CSCHED2_VCPU(idle_vcpu[cpu]);
}
else
snext=runq_candidate(rqd, scurr, cpu, now);
@@ -1743,7 +1743,7 @@ csched_schedule(
}
/* Check for the reset condition */
- if ( snext->credit <= CSCHED_CREDIT_RESET )
+ if ( snext->credit <= CSCHED2_CREDIT_RESET )
{
reset_credit(ops, cpu, now, snext);
balance_load(ops, cpu, now);
@@ -1758,7 +1758,7 @@ csched_schedule(
/* Safe because lock for old processor is held */
if ( snext->vcpu->processor != cpu )
{
- snext->credit += CSCHED_MIGRATE_COMPENSATION;
+ snext->credit += CSCHED2_MIGRATE_COMPENSATION;
snext->vcpu->processor = cpu;
ret.migrated = 1;
}
@@ -1776,15 +1776,15 @@ csched_schedule(
/*
* Return task to run next...
*/
- ret.time = csched_runtime(ops, cpu, snext);
+ ret.time = csched2_runtime(ops, cpu, snext);
ret.task = snext->vcpu;
- CSCHED_VCPU_CHECK(ret.task);
+ CSCHED2_VCPU_CHECK(ret.task);
return ret;
}
static void
-csched_dump_vcpu(struct csched_vcpu *svc)
+csched2_dump_vcpu(struct csched2_vcpu *svc)
{
printk("[%i.%i] flags=%x cpu=%i",
svc->vcpu->domain->domain_id,
@@ -1798,10 +1798,10 @@ csched_dump_vcpu(struct csched_vcpu *svc)
}
static void
-csched_dump_pcpu(const struct scheduler *ops, int cpu)
+csched2_dump_pcpu(const struct scheduler *ops, int cpu)
{
struct list_head *runq, *iter;
- struct csched_vcpu *svc;
+ struct csched2_vcpu *svc;
int loop;
char cpustr[100];
@@ -1815,11 +1815,11 @@ csched_dump_pcpu(const struct scheduler *ops, int cpu)
printk("core=%s\n", cpustr);
/* current VCPU */
- svc = CSCHED_VCPU(per_cpu(schedule_data, cpu).curr);
+ svc = CSCHED2_VCPU(per_cpu(schedule_data, cpu).curr);
if ( svc )
{
printk("\trun: ");
- csched_dump_vcpu(svc);
+ csched2_dump_vcpu(svc);
}
loop = 0;
@@ -1829,22 +1829,22 @@ csched_dump_pcpu(const struct scheduler *ops, int cpu)
if ( svc )
{
printk("\t%3d: ", ++loop);
- csched_dump_vcpu(svc);
+ csched2_dump_vcpu(svc);
}
}
}
static void
-csched_dump(const struct scheduler *ops)
+csched2_dump(const struct scheduler *ops)
{
struct list_head *iter_sdom, *iter_svc;
- struct csched_private *prv = CSCHED_PRIV(ops);
+ struct csched2_private *prv = CSCHED2_PRIV(ops);
int i, loop;
printk("Active queues: %d\n"
"\tdefault-weight = %d\n",
cpumask_weight(&prv->active_queues),
- CSCHED_DEFAULT_WEIGHT);
+ CSCHED2_DEFAULT_WEIGHT);
for_each_cpu(i, &prv->active_queues)
{
s_time_t fraction;
@@ -1869,8 +1869,8 @@ csched_dump(const struct scheduler *ops)
loop = 0;
list_for_each( iter_sdom, &prv->sdom )
{
- struct csched_dom *sdom;
- sdom = list_entry(iter_sdom, struct csched_dom, sdom_elem);
+ struct csched2_dom *sdom;
+ sdom = list_entry(iter_sdom, struct csched2_dom, sdom_elem);
printk("\tDomain: %d w %d v %d\n\t",
sdom->dom->domain_id,
@@ -1879,18 +1879,18 @@ csched_dump(const struct scheduler *ops)
list_for_each( iter_svc, &sdom->vcpu )
{
- struct csched_vcpu *svc;
- svc = list_entry(iter_svc, struct csched_vcpu, sdom_elem);
+ struct csched2_vcpu *svc;
+ svc = list_entry(iter_svc, struct csched2_vcpu, sdom_elem);
printk("\t%3d: ", ++loop);
- csched_dump_vcpu(svc);
+ csched2_dump_vcpu(svc);
}
}
}
-static void activate_runqueue(struct csched_private *prv, int rqi)
+static void activate_runqueue(struct csched2_private *prv, int rqi)
{
- struct csched_runqueue_data *rqd;
+ struct csched2_runqueue_data *rqd;
rqd = prv->rqd + rqi;
@@ -1905,9 +1905,9 @@ static void activate_runqueue(struct csched_private *prv,
int rqi)
cpumask_set_cpu(rqi, &prv->active_queues);
}
-static void deactivate_runqueue(struct csched_private *prv, int rqi)
+static void deactivate_runqueue(struct csched2_private *prv, int rqi)
{
- struct csched_runqueue_data *rqd;
+ struct csched2_runqueue_data *rqd;
rqd = prv->rqd + rqi;
@@ -1922,8 +1922,8 @@ static void init_pcpu(const struct scheduler *ops, int
cpu)
{
int rqi;
unsigned long flags;
- struct csched_private *prv = CSCHED_PRIV(ops);
- struct csched_runqueue_data *rqd;
+ struct csched2_private *prv = CSCHED2_PRIV(ops);
+ struct csched2_runqueue_data *rqd;
spinlock_t *old_lock;
spin_lock_irqsave(&prv->lock, flags);
@@ -1984,7 +1984,7 @@ static void init_pcpu(const struct scheduler *ops, int
cpu)
}
static void *
-csched_alloc_pdata(const struct scheduler *ops, int cpu)
+csched2_alloc_pdata(const struct scheduler *ops, int cpu)
{
/* Check to see if the cpu is online yet */
/* Note: cpu 0 doesn't get a STARTING callback */
@@ -1998,11 +1998,11 @@ csched_alloc_pdata(const struct scheduler *ops, int cpu)
}
static void
-csched_free_pdata(const struct scheduler *ops, void *pcpu, int cpu)
+csched2_free_pdata(const struct scheduler *ops, void *pcpu, int cpu)
{
unsigned long flags;
- struct csched_private *prv = CSCHED_PRIV(ops);
- struct csched_runqueue_data *rqd;
+ struct csched2_private *prv = CSCHED2_PRIV(ops);
+ struct csched2_runqueue_data *rqd;
struct schedule_data *sd = &per_cpu(schedule_data, cpu);
int rqi;
@@ -2046,14 +2046,14 @@ csched_free_pdata(const struct scheduler *ops, void
*pcpu, int cpu)
}
static int
-csched_cpu_starting(int cpu)
+csched2_cpu_starting(int cpu)
{
struct scheduler *ops;
/* Hope this is safe from cpupools switching things around. :-) */
ops = per_cpu(scheduler, cpu);
- if ( ops->alloc_pdata == csched_alloc_pdata )
+ if ( ops->alloc_pdata == csched2_alloc_pdata )
init_pcpu(ops, cpu);
return NOTIFY_DONE;
@@ -2068,7 +2068,7 @@ static int cpu_credit2_callback(
switch ( action )
{
case CPU_STARTING:
- csched_cpu_starting(cpu);
+ csched2_cpu_starting(cpu);
break;
default:
break;
@@ -2082,17 +2082,17 @@ static struct notifier_block cpu_credit2_nfb = {
};
static int
-csched_global_init(void)
+csched2_global_init(void)
{
register_cpu_notifier(&cpu_credit2_nfb);
return 0;
}
static int
-csched_init(struct scheduler *ops)
+csched2_init(struct scheduler *ops)
{
int i;
- struct csched_private *prv;
+ struct csched2_private *prv;
printk("Initializing Credit2 scheduler\n" \
" WARNING: This is experimental software in development.\n" \
@@ -2113,7 +2113,7 @@ csched_init(struct scheduler *ops)
* set up basic structures, and a callback when the CPU info is
* available. */
- prv = xzalloc(struct csched_private);
+ prv = xzalloc(struct csched2_private);
if ( prv == NULL )
return -ENOMEM;
ops->sched_data = prv;
@@ -2133,49 +2133,49 @@ csched_init(struct scheduler *ops)
}
static void
-csched_deinit(const struct scheduler *ops)
+csched2_deinit(const struct scheduler *ops)
{
- struct csched_private *prv;
+ struct csched2_private *prv;
- prv = CSCHED_PRIV(ops);
+ prv = CSCHED2_PRIV(ops);
if ( prv != NULL )
xfree(prv);
}
-static struct csched_private _csched_priv;
+static struct csched2_private _csched2_priv;
const struct scheduler sched_credit2_def = {
.name = "SMP Credit Scheduler rev2",
.opt_name = "credit2",
.sched_id = XEN_SCHEDULER_CREDIT2,
- .sched_data = &_csched_priv,
-
- .init_domain = csched_dom_init,
- .destroy_domain = csched_dom_destroy,
-
- .insert_vcpu = csched_vcpu_insert,
- .remove_vcpu = csched_vcpu_remove,
-
- .sleep = csched_vcpu_sleep,
- .wake = csched_vcpu_wake,
-
- .adjust = csched_dom_cntl,
-
- .pick_cpu = csched_cpu_pick,
- .migrate = csched_vcpu_migrate,
- .do_schedule = csched_schedule,
- .context_saved = csched_context_saved,
-
- .dump_cpu_state = csched_dump_pcpu,
- .dump_settings = csched_dump,
- .global_init = csched_global_init,
- .init = csched_init,
- .deinit = csched_deinit,
- .alloc_vdata = csched_alloc_vdata,
- .free_vdata = csched_free_vdata,
- .alloc_pdata = csched_alloc_pdata,
- .free_pdata = csched_free_pdata,
- .alloc_domdata = csched_alloc_domdata,
- .free_domdata = csched_free_domdata,
+ .sched_data = &_csched2_priv,
+
+ .init_domain = csched2_dom_init,
+ .destroy_domain = csched2_dom_destroy,
+
+ .insert_vcpu = csched2_vcpu_insert,
+ .remove_vcpu = csched2_vcpu_remove,
+
+ .sleep = csched2_vcpu_sleep,
+ .wake = csched2_vcpu_wake,
+
+ .adjust = csched2_dom_cntl,
+
+ .pick_cpu = csched2_cpu_pick,
+ .migrate = csched2_vcpu_migrate,
+ .do_schedule = csched2_schedule,
+ .context_saved = csched2_context_saved,
+
+ .dump_cpu_state = csched2_dump_pcpu,
+ .dump_settings = csched2_dump,
+ .global_init = csched2_global_init,
+ .init = csched2_init,
+ .deinit = csched2_deinit,
+ .alloc_vdata = csched2_alloc_vdata,
+ .free_vdata = csched2_free_vdata,
+ .alloc_pdata = csched2_alloc_pdata,
+ .free_pdata = csched2_free_pdata,
+ .alloc_domdata = csched2_alloc_domdata,
+ .free_domdata = csched2_free_domdata,
};
--
generated by git-patchbot for /home/xen/git/xen.git#master
_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |