* [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support
@ 2019-09-14 8:52 Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 01/47] xen/sched: use new sched_unit instead of vcpu in scheduler interfaces Juergen Gross
` (48 more replies)
0 siblings, 49 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Robert VanVossen, Dario Faggioli, Julien Grall, Josh Whitehead,
Meng Xu, Jan Beulich, Volodymyr Babchuk, Roger Pau Monné
Add support for core- and socket-scheduling in the Xen hypervisor.
Via boot parameter sched-gran=core (or sched-gran=socket)
it is possible to change the scheduling granularity from cpu (the
default) to either whole cores or even sockets.
All logical cpus (threads) of the core or socket are always scheduled
together. This means that on a core always vcpus of the same domain
will be active, and those vcpus will always be scheduled at the same
time.
This is achieved by switching the scheduler to no longer see vcpus as
the primary object to schedule, but "schedule units". Each schedule
unit consists of as many vcpus as each core has threads on the current
system. The vcpu->unit relation is fixed.
I have done some very basic performance testing: on a 4 cpu system
(2 cores with 2 threads each) I did a "make -j 4" for building the Xen
hypervisor. With This test has been run on dom0, once with no other
guest active and once with another guest with 4 vcpus running the same
test. The results are (always elapsed time, system time, user time):
sched-gran=cpu, no other guest: 116.10 177.65 207.84
sched-gran=core, no other guest: 114.04 175.47 207.45
sched-gran=cpu, other guest: 202.30 334.21 384.63
sched-gran=core, other guest: 207.24 293.04 371.37
The performance tests have been performed with credit2, the other
schedulers are tested only briefly to be able to create a domain in a
cpupool.
Cpupools have been moderately tested (cpu add/remove, create, destroy,
move domain).
Cpu on-/offlining has been moderately tested, too.
The series is based on the series:
"xen/sched: use new idle scheduler for free cpus"
which has been split off from V1 and on the patch:
"xen/sched: rework and rename vcpu_force_reschedule()"
which has been split off from V2.
The complete patch series is available under:
git://github.com/jgross1/xen/ sched-v3
Changes in V3:
- comments addressed
- former patch 26 carved out and sent separately
- some minor bugs fixed
Changes in V2:
- comments addressed
- some patches merged into one
- idle scheduler related patches split off to own series
- some patches are already applied
- some bugs fixed (e.g. crashes when powering off)
Changes in V1:
- cpupools are working now
- cpu on-/offlining working now
- all schedulers working now
- renamed "items" to "units"
- introduction of "idle scheduler"
- several new patches (see individual patches, mostly splits of
former patches or cpupool and cpu on-/offlining support)
- all review comments addressed
- some minor changes (see individual patches)
Changes in RFC V2:
- ARM is building now
- HVM domains are working now
- idling will always be done with idle_vcpu active
- other small changes see individual patches
Juergen Gross (47):
xen/sched: use new sched_unit instead of vcpu in scheduler interfaces
xen/sched: move per-vcpu scheduler private data pointer to sched_unit
xen/sched: build a linked list of struct sched_unit
xen/sched: introduce struct sched_resource
xen/sched: let pick_cpu return a scheduler resource
xen/sched: switch schedule_data.curr to point at sched_unit
xen/sched: move per cpu scheduler private data into struct
sched_resource
xen/sched: switch vcpu_schedule_lock to unit_schedule_lock
xen/sched: move some per-vcpu items to struct sched_unit
xen/sched: add scheduler helpers hiding vcpu
xen/sched: rename scheduler related perf counters
xen/sched: switch struct task_slice from vcpu to sched_unit
xen/sched: add is_running indicator to struct sched_unit
xen/sched: make null scheduler vcpu agnostic.
xen/sched: make rt scheduler vcpu agnostic.
xen/sched: make credit scheduler vcpu agnostic.
xen/sched: make credit2 scheduler vcpu agnostic.
xen/sched: make arinc653 scheduler vcpu agnostic.
xen: add sched_unit_pause_nosync() and sched_unit_unpause()
xen: let vcpu_create() select processor
xen/sched: use sched_resource cpu instead smp_processor_id in
schedulers
xen/sched: switch schedule() from vcpus to sched_units
xen/sched: switch sched_move_irqs() to take sched_unit as parameter
xen: switch from for_each_vcpu() to for_each_sched_unit()
xen/sched: add runstate counters to struct sched_unit
xen/sched: Change vcpu_migrate_*() to operate on schedule unit
xen/sched: move struct task_slice into struct sched_unit
xen/sched: add code to sync scheduling of all vcpus of a sched unit
xen/sched: introduce unit_runnable_state()
xen/sched: add support for multiple vcpus per sched unit where missing
xen/sched: modify cpupool_domain_cpumask() to be an unit mask
xen/sched: support allocating multiple vcpus into one sched unit
xen/sched: add a percpu resource index
xen/sched: add fall back to idle vcpu when scheduling unit
xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware
xen/sched: carve out freeing sched_unit memory into dedicated function
xen/sched: move per-cpu variable scheduler to struct sched_resource
xen/sched: move per-cpu variable cpupool to struct sched_resource
xen/sched: reject switching smt on/off with core scheduling active
xen/sched: prepare per-cpupool scheduling granularity
xen/sched: split schedule_cpu_switch()
xen/sched: protect scheduling resource via rcu
xen/sched: support multiple cpus per scheduling resource
xen/sched: support differing granularity in schedule_cpu_[add/rm]()
xen/sched: support core scheduling for moving cpus to/from cpupools
xen/sched: disable scheduling when entering ACPI deep sleep states
xen/sched: add scheduling granularity enum
xen/arch/arm/domain.c | 2 +-
xen/arch/arm/domain_build.c | 13 +-
xen/arch/x86/Kconfig | 1 +
xen/arch/x86/acpi/power.c | 4 +
xen/arch/x86/dom0_build.c | 10 +-
xen/arch/x86/domain.c | 26 +-
xen/arch/x86/hvm/dom0_build.c | 9 +-
xen/arch/x86/pv/dom0_build.c | 10 +-
xen/arch/x86/sysctl.c | 5 +
xen/common/Kconfig | 3 +
xen/common/cpupool.c | 155 +++-
xen/common/domain.c | 29 +-
xen/common/domctl.c | 23 +-
xen/common/keyhandler.c | 58 +-
xen/common/sched_arinc653.c | 257 +++---
xen/common/sched_credit.c | 762 ++++++++--------
xen/common/sched_credit2.c | 1121 ++++++++++++------------
xen/common/sched_null.c | 472 +++++-----
xen/common/sched_rt.c | 545 ++++++------
xen/common/schedule.c | 1787 +++++++++++++++++++++++++++++++-------
xen/common/softirq.c | 6 +-
xen/include/asm-arm/current.h | 1 +
xen/include/asm-x86/cpuidle.h | 11 -
xen/include/asm-x86/current.h | 19 +-
xen/include/asm-x86/dom0_build.h | 3 +-
xen/include/asm-x86/smp.h | 3 +
xen/include/xen/domain.h | 3 +-
xen/include/xen/perfc_defn.h | 32 +-
xen/include/xen/sched-if.h | 343 ++++++--
xen/include/xen/sched.h | 99 ++-
xen/include/xen/softirq.h | 1 +
31 files changed, 3649 insertions(+), 2164 deletions(-)
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 01/47] xen/sched: use new sched_unit instead of vcpu in scheduler interfaces
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 02/47] xen/sched: move per-vcpu scheduler private data pointer to sched_unit Juergen Gross
` (47 subsequent siblings)
48 siblings, 0 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Robert VanVossen, Dario Faggioli, Julien Grall, Josh Whitehead,
Meng Xu, Jan Beulich
In order to prepare core- and socket-scheduling use a new struct
sched_unit instead of struct vcpu for interfaces of the different
schedulers.
Rename the per-scheduler functions insert_vcpu and remove_vcpu to
insert_unit and remove_unit to reflect the change of the parameter.
In the schedulers rename local functions switched to sched_unit, too.
For now this new struct will contain a domain, a vcpu pointer and a
unit_id only and is allocated at vcpu creation time.
Signed-off-by: Juergen Gross <jgross@suse.com>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
---
RFC V2:
- move definition of struct sched_unit to sched.h (Andrew Cooper)
V1:
- rename "item" to "unit" (George Dunlap)
V2:
- rename unit->vcpu to unit->vcpu_list (Jan Beulich)
- merge patch with next one in series (Dario Faggioli)
- merge patch introducing domain pointer in sched_unit into this one
(Jan Beulich)
- merge patch introducing unit_id into this one
V3:
- make unit parameter of pick_cpu const (Jan Beulich)
- set vcpu->unit only after intializing uniti, freeing unit only after
clearing vcpu->unit (Jan Beulich)
- remove pre-definition of struct sched_unit in sched.h (Jan Beulich)
- make unit_id unsigned int (Jan Beulich)
---
xen/common/sched_arinc653.c | 30 +++++++++------
xen/common/sched_credit.c | 41 ++++++++++++--------
xen/common/sched_credit2.c | 57 ++++++++++++++++------------
xen/common/sched_null.c | 38 ++++++++++++-------
xen/common/sched_rt.c | 33 +++++++++-------
xen/common/schedule.c | 54 +++++++++++++++++---------
xen/include/xen/sched-if.h | 92 ++++++++++++++++++++++++++-------------------
xen/include/xen/sched.h | 7 ++++
8 files changed, 219 insertions(+), 133 deletions(-)
diff --git a/xen/common/sched_arinc653.c b/xen/common/sched_arinc653.c
index 72b988ea5f..e8b13a0022 100644
--- a/xen/common/sched_arinc653.c
+++ b/xen/common/sched_arinc653.c
@@ -376,13 +376,16 @@ a653sched_deinit(struct scheduler *ops)
* This function allocates scheduler-specific data for a VCPU
*
* @param ops Pointer to this instance of the scheduler structure
+ * @param unit Pointer to struct sched_unit
*
* @return Pointer to the allocated data
*/
static void *
-a653sched_alloc_vdata(const struct scheduler *ops, struct vcpu *vc, void *dd)
+a653sched_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
+ void *dd)
{
a653sched_priv_t *sched_priv = SCHED_PRIV(ops);
+ struct vcpu *vc = unit->vcpu_list;
arinc653_vcpu_t *svc;
unsigned int entry;
unsigned long flags;
@@ -458,11 +461,13 @@ a653sched_free_vdata(const struct scheduler *ops, void *priv)
* Xen scheduler callback function to sleep a VCPU
*
* @param ops Pointer to this instance of the scheduler structure
- * @param vc Pointer to the VCPU structure for the current domain
+ * @param unit Pointer to struct sched_unit
*/
static void
-a653sched_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc)
+a653sched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
+
if ( AVCPU(vc) != NULL )
AVCPU(vc)->awake = 0;
@@ -478,11 +483,13 @@ a653sched_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc)
* Xen scheduler callback function to wake up a VCPU
*
* @param ops Pointer to this instance of the scheduler structure
- * @param vc Pointer to the VCPU structure for the current domain
+ * @param unit Pointer to struct sched_unit
*/
static void
-a653sched_vcpu_wake(const struct scheduler *ops, struct vcpu *vc)
+a653sched_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
+
if ( AVCPU(vc) != NULL )
AVCPU(vc)->awake = 1;
@@ -597,13 +604,14 @@ a653sched_do_schedule(
* Xen scheduler callback function to select a CPU for the VCPU to run on
*
* @param ops Pointer to this instance of the scheduler structure
- * @param v Pointer to the VCPU structure for the current domain
+ * @param unit Pointer to struct sched_unit
*
* @return Number of selected physical CPU
*/
static int
-a653sched_pick_cpu(const struct scheduler *ops, struct vcpu *vc)
+a653sched_pick_cpu(const struct scheduler *ops, const struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
cpumask_t *online;
unsigned int cpu;
@@ -702,11 +710,11 @@ static const struct scheduler sched_arinc653_def = {
.free_vdata = a653sched_free_vdata,
.alloc_vdata = a653sched_alloc_vdata,
- .insert_vcpu = NULL,
- .remove_vcpu = NULL,
+ .insert_unit = NULL,
+ .remove_unit = NULL,
- .sleep = a653sched_vcpu_sleep,
- .wake = a653sched_vcpu_wake,
+ .sleep = a653sched_unit_sleep,
+ .wake = a653sched_unit_wake,
.yield = NULL,
.context_saved = NULL,
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index 70fe718127..94d733dcb5 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -854,15 +854,16 @@ _csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc, bool_t commit)
}
static int
-csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc)
+csched_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched_vcpu *svc = CSCHED_VCPU(vc);
/*
* We have been called by vcpu_migrate() (in schedule.c), as part
* of the process of seeing if vc can be migrated to another pcpu.
* We make a note about this in svc->flags so that later, in
- * csched_vcpu_wake() (still called from vcpu_migrate()) we won't
+ * csched_unit_wake() (still called from vcpu_migrate()) we won't
* get boosted, which we don't deserve as we are "only" migrating.
*/
set_bit(CSCHED_FLAG_VCPU_MIGRATING, &svc->flags);
@@ -990,8 +991,10 @@ csched_vcpu_acct(struct csched_private *prv, unsigned int cpu)
}
static void *
-csched_alloc_vdata(const struct scheduler *ops, struct vcpu *vc, void *dd)
+csched_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
+ void *dd)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched_vcpu *svc;
/* Allocate per-VCPU info */
@@ -1011,8 +1014,9 @@ csched_alloc_vdata(const struct scheduler *ops, struct vcpu *vc, void *dd)
}
static void
-csched_vcpu_insert(const struct scheduler *ops, struct vcpu *vc)
+csched_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched_vcpu *svc = vc->sched_priv;
spinlock_t *lock;
@@ -1021,7 +1025,7 @@ csched_vcpu_insert(const struct scheduler *ops, struct vcpu *vc)
/* csched_cpu_pick() looks in vc->processor's runq, so we need the lock. */
lock = vcpu_schedule_lock_irq(vc);
- vc->processor = csched_cpu_pick(ops, vc);
+ vc->processor = csched_cpu_pick(ops, unit);
spin_unlock_irq(lock);
@@ -1046,9 +1050,10 @@ csched_free_vdata(const struct scheduler *ops, void *priv)
}
static void
-csched_vcpu_remove(const struct scheduler *ops, struct vcpu *vc)
+csched_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
{
struct csched_private *prv = CSCHED_PRIV(ops);
+ struct vcpu *vc = unit->vcpu_list;
struct csched_vcpu * const svc = CSCHED_VCPU(vc);
struct csched_dom * const sdom = svc->sdom;
@@ -1073,8 +1078,9 @@ csched_vcpu_remove(const struct scheduler *ops, struct vcpu *vc)
}
static void
-csched_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc)
+csched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched_vcpu * const svc = CSCHED_VCPU(vc);
unsigned int cpu = vc->processor;
@@ -1097,8 +1103,9 @@ csched_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc)
}
static void
-csched_vcpu_wake(const struct scheduler *ops, struct vcpu *vc)
+csched_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched_vcpu * const svc = CSCHED_VCPU(vc);
bool_t migrating;
@@ -1158,8 +1165,9 @@ csched_vcpu_wake(const struct scheduler *ops, struct vcpu *vc)
}
static void
-csched_vcpu_yield(const struct scheduler *ops, struct vcpu *vc)
+csched_unit_yield(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched_vcpu * const svc = CSCHED_VCPU(vc);
/* Let the scheduler know that this vcpu is trying to yield */
@@ -1212,9 +1220,10 @@ csched_dom_cntl(
}
static void
-csched_aff_cntl(const struct scheduler *ops, struct vcpu *v,
+csched_aff_cntl(const struct scheduler *ops, struct sched_unit *unit,
const cpumask_t *hard, const cpumask_t *soft)
{
+ struct vcpu *v = unit->vcpu_list;
struct csched_vcpu *svc = CSCHED_VCPU(v);
if ( !hard )
@@ -1743,7 +1752,7 @@ csched_load_balance(struct csched_private *prv, int cpu,
* - if we race with inc_nr_runnable(), we skip a pCPU that may
* have runnable vCPUs in its runqueue, but that's not a
* problem because:
- * + if racing with csched_vcpu_insert() or csched_vcpu_wake(),
+ * + if racing with csched_unit_insert() or csched_unit_wake(),
* __runq_tickle() will be called afterwords, so the vCPU
* won't get stuck in the runqueue for too long;
* + if racing with csched_runq_steal(), it may be that a
@@ -2256,12 +2265,12 @@ static const struct scheduler sched_credit_def = {
.global_init = csched_global_init,
- .insert_vcpu = csched_vcpu_insert,
- .remove_vcpu = csched_vcpu_remove,
+ .insert_unit = csched_unit_insert,
+ .remove_unit = csched_unit_remove,
- .sleep = csched_vcpu_sleep,
- .wake = csched_vcpu_wake,
- .yield = csched_vcpu_yield,
+ .sleep = csched_unit_sleep,
+ .wake = csched_unit_wake,
+ .yield = csched_unit_yield,
.adjust = csched_dom_cntl,
.adjust_affinity= csched_aff_cntl,
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 6b77da7476..1973dbddcc 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -273,7 +273,7 @@
* 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 csched2_schedule() if prev is runnable
- * + Set in csched2_vcpu_wake if it finds CSFLAG_scheduled set
+ * + Set in csched2_unit_wake if it finds CSFLAG_scheduled set
* + Read in csched2_context_saved(). If set, it adds prev to the runqueue and
* clears the bit.
*/
@@ -624,14 +624,14 @@ static inline bool has_cap(const struct csched2_vcpu *svc)
* This logic is entirely implemented in runq_tickle(), and that is enough.
* In fact, in this scheduler, placement of a vcpu on one of the pcpus of a
* runq, _always_ happens by means of tickling:
- * - when a vcpu wakes up, it calls csched2_vcpu_wake(), which calls
+ * - when a vcpu wakes up, it calls csched2_unit_wake(), which calls
* runq_tickle();
* - when a migration is initiated in schedule.c, we call csched2_cpu_pick(),
- * csched2_vcpu_migrate() (which calls migrate()) and csched2_vcpu_wake().
+ * csched2_unit_migrate() (which calls migrate()) and csched2_unit_wake().
* csched2_cpu_pick() looks for the least loaded runq and return just any
- * of its processors. Then, csched2_vcpu_migrate() just moves the vcpu to
+ * of its processors. Then, csched2_unit_migrate() just moves the vcpu to
* the chosen runq, and it is again runq_tickle(), called by
- * csched2_vcpu_wake() that actually decides what pcpu to use within the
+ * csched2_unit_wake() that actually decides what pcpu to use within the
* chosen runq;
* - when a migration is initiated in sched_credit2.c, by calling migrate()
* directly, that again temporarily use a random pcpu from the new runq,
@@ -2027,8 +2027,10 @@ csched2_vcpu_check(struct vcpu *vc)
#endif
static void *
-csched2_alloc_vdata(const struct scheduler *ops, struct vcpu *vc, void *dd)
+csched2_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
+ void *dd)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched2_vcpu *svc;
/* Allocate per-VCPU info */
@@ -2070,8 +2072,9 @@ csched2_alloc_vdata(const struct scheduler *ops, struct vcpu *vc, void *dd)
}
static void
-csched2_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc)
+csched2_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched2_vcpu * const svc = csched2_vcpu(vc);
ASSERT(!is_idle_vcpu(vc));
@@ -2092,8 +2095,9 @@ csched2_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc)
}
static void
-csched2_vcpu_wake(const struct scheduler *ops, struct vcpu *vc)
+csched2_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched2_vcpu * const svc = csched2_vcpu(vc);
unsigned int cpu = vc->processor;
s_time_t now;
@@ -2147,16 +2151,18 @@ out:
}
static void
-csched2_vcpu_yield(const struct scheduler *ops, struct vcpu *v)
+csched2_unit_yield(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *v = unit->vcpu_list;
struct csched2_vcpu * const svc = csched2_vcpu(v);
__set_bit(__CSFLAG_vcpu_yield, &svc->flags);
}
static void
-csched2_context_saved(const struct scheduler *ops, struct vcpu *vc)
+csched2_context_saved(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched2_vcpu * const svc = csched2_vcpu(vc);
spinlock_t *lock = vcpu_schedule_lock_irq(vc);
s_time_t now = NOW();
@@ -2197,9 +2203,10 @@ csched2_context_saved(const struct scheduler *ops, struct vcpu *vc)
#define MAX_LOAD (STIME_MAX)
static int
-csched2_cpu_pick(const struct scheduler *ops, struct vcpu *vc)
+csched2_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
struct csched2_private *prv = csched2_priv(ops);
+ struct vcpu *vc = unit->vcpu_list;
int i, min_rqi = -1, min_s_rqi = -1;
unsigned int new_cpu, cpu = vc->processor;
struct csched2_vcpu *svc = csched2_vcpu(vc);
@@ -2734,9 +2741,10 @@ retry:
}
static void
-csched2_vcpu_migrate(
- const struct scheduler *ops, struct vcpu *vc, unsigned int new_cpu)
+csched2_unit_migrate(
+ const struct scheduler *ops, struct sched_unit *unit, unsigned int new_cpu)
{
+ struct vcpu *vc = unit->vcpu_list;
struct domain *d = vc->domain;
struct csched2_vcpu * const svc = csched2_vcpu(vc);
struct csched2_runqueue_data *trqd;
@@ -2997,9 +3005,10 @@ csched2_dom_cntl(
}
static void
-csched2_aff_cntl(const struct scheduler *ops, struct vcpu *v,
+csched2_aff_cntl(const struct scheduler *ops, struct sched_unit *unit,
const cpumask_t *hard, const cpumask_t *soft)
{
+ struct vcpu *v = unit->vcpu_list;
struct csched2_vcpu *svc = csched2_vcpu(v);
if ( !hard )
@@ -3097,8 +3106,9 @@ csched2_free_domdata(const struct scheduler *ops, void *data)
}
static void
-csched2_vcpu_insert(const struct scheduler *ops, struct vcpu *vc)
+csched2_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched2_vcpu *svc = vc->sched_priv;
struct csched2_dom * const sdom = svc->sdom;
spinlock_t *lock;
@@ -3109,7 +3119,7 @@ csched2_vcpu_insert(const struct scheduler *ops, struct vcpu *vc)
/* csched2_cpu_pick() expects the pcpu lock to be held */
lock = vcpu_schedule_lock_irq(vc);
- vc->processor = csched2_cpu_pick(ops, vc);
+ vc->processor = csched2_cpu_pick(ops, unit);
spin_unlock_irq(lock);
@@ -3136,8 +3146,9 @@ csched2_free_vdata(const struct scheduler *ops, void *priv)
}
static void
-csched2_vcpu_remove(const struct scheduler *ops, struct vcpu *vc)
+csched2_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct csched2_vcpu * const svc = csched2_vcpu(vc);
spinlock_t *lock;
@@ -4083,19 +4094,19 @@ static const struct scheduler sched_credit2_def = {
.global_init = csched2_global_init,
- .insert_vcpu = csched2_vcpu_insert,
- .remove_vcpu = csched2_vcpu_remove,
+ .insert_unit = csched2_unit_insert,
+ .remove_unit = csched2_unit_remove,
- .sleep = csched2_vcpu_sleep,
- .wake = csched2_vcpu_wake,
- .yield = csched2_vcpu_yield,
+ .sleep = csched2_unit_sleep,
+ .wake = csched2_unit_wake,
+ .yield = csched2_unit_yield,
.adjust = csched2_dom_cntl,
.adjust_affinity= csched2_aff_cntl,
.adjust_global = csched2_sys_cntl,
.pick_cpu = csched2_cpu_pick,
- .migrate = csched2_vcpu_migrate,
+ .migrate = csched2_unit_migrate,
.do_schedule = csched2_schedule,
.context_saved = csched2_context_saved,
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index 6782ecda5c..a5a9ce2d57 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -186,8 +186,9 @@ static void null_deinit_pdata(const struct scheduler *ops, void *pcpu, int cpu)
}
static void *null_alloc_vdata(const struct scheduler *ops,
- struct vcpu *v, void *dd)
+ struct sched_unit *unit, void *dd)
{
+ struct vcpu *v = unit->vcpu_list;
struct null_vcpu *nvc;
nvc = xzalloc(struct null_vcpu);
@@ -435,8 +436,10 @@ static spinlock_t *null_switch_sched(struct scheduler *new_ops,
return &sd->_lock;
}
-static void null_vcpu_insert(const struct scheduler *ops, struct vcpu *v)
+static void null_unit_insert(const struct scheduler *ops,
+ struct sched_unit *unit)
{
+ struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
struct null_vcpu *nvc = null_vcpu(v);
unsigned int cpu;
@@ -496,8 +499,10 @@ static void null_vcpu_insert(const struct scheduler *ops, struct vcpu *v)
SCHED_STAT_CRANK(vcpu_insert);
}
-static void null_vcpu_remove(const struct scheduler *ops, struct vcpu *v)
+static void null_unit_remove(const struct scheduler *ops,
+ struct sched_unit *unit)
{
+ struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
struct null_vcpu *nvc = null_vcpu(v);
spinlock_t *lock;
@@ -532,8 +537,10 @@ static void null_vcpu_remove(const struct scheduler *ops, struct vcpu *v)
SCHED_STAT_CRANK(vcpu_remove);
}
-static void null_vcpu_wake(const struct scheduler *ops, struct vcpu *v)
+static void null_unit_wake(const struct scheduler *ops,
+ struct sched_unit *unit)
{
+ struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
struct null_vcpu *nvc = null_vcpu(v);
unsigned int cpu = v->processor;
@@ -604,8 +611,10 @@ static void null_vcpu_wake(const struct scheduler *ops, struct vcpu *v)
cpu_raise_softirq(v->processor, SCHEDULE_SOFTIRQ);
}
-static void null_vcpu_sleep(const struct scheduler *ops, struct vcpu *v)
+static void null_unit_sleep(const struct scheduler *ops,
+ struct sched_unit *unit)
{
+ struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
unsigned int cpu = v->processor;
bool tickled = false;
@@ -637,15 +646,18 @@ static void null_vcpu_sleep(const struct scheduler *ops, struct vcpu *v)
SCHED_STAT_CRANK(vcpu_sleep);
}
-static int null_cpu_pick(const struct scheduler *ops, struct vcpu *v)
+static int null_cpu_pick(const struct scheduler *ops,
+ const struct sched_unit *unit)
{
+ struct vcpu *v = unit->vcpu_list;
ASSERT(!is_idle_vcpu(v));
return pick_cpu(null_priv(ops), v);
}
-static void null_vcpu_migrate(const struct scheduler *ops, struct vcpu *v,
- unsigned int new_cpu)
+static void null_unit_migrate(const struct scheduler *ops,
+ struct sched_unit *unit, unsigned int new_cpu)
{
+ struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
struct null_vcpu *nvc = null_vcpu(v);
@@ -965,13 +977,13 @@ static const struct scheduler sched_null_def = {
.alloc_domdata = null_alloc_domdata,
.free_domdata = null_free_domdata,
- .insert_vcpu = null_vcpu_insert,
- .remove_vcpu = null_vcpu_remove,
+ .insert_unit = null_unit_insert,
+ .remove_unit = null_unit_remove,
- .wake = null_vcpu_wake,
- .sleep = null_vcpu_sleep,
+ .wake = null_unit_wake,
+ .sleep = null_unit_sleep,
.pick_cpu = null_cpu_pick,
- .migrate = null_vcpu_migrate,
+ .migrate = null_unit_migrate,
.do_schedule = null_schedule,
.dump_cpu_state = null_dump_pcpu,
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index e0e350bdf3..0f5e0ebcc1 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -136,7 +136,7 @@
* RTDS_delayed_runq_add: Do we need to add this to the RunQ/DepletedQ
* once it's done being context switching out?
* + Set when scheduling out in rt_schedule() if prev is runable
- * + Set in rt_vcpu_wake if it finds RTDS_scheduled set
+ * + Set in rt_unit_wake if it finds RTDS_scheduled set
* + Read in rt_context_saved(). If set, it adds prev to the Runqueue/DepletedQ
* and clears the bit.
*/
@@ -636,8 +636,9 @@ replq_reinsert(const struct scheduler *ops, struct rt_vcpu *svc)
* and available cpus
*/
static int
-rt_cpu_pick(const struct scheduler *ops, struct vcpu *vc)
+rt_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
cpumask_t cpus;
cpumask_t *online;
int cpu;
@@ -837,8 +838,9 @@ rt_free_domdata(const struct scheduler *ops, void *data)
}
static void *
-rt_alloc_vdata(const struct scheduler *ops, struct vcpu *vc, void *dd)
+rt_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit, void *dd)
{
+ struct vcpu *vc = unit->vcpu_list;
struct rt_vcpu *svc;
/* Allocate per-VCPU info */
@@ -880,8 +882,9 @@ rt_free_vdata(const struct scheduler *ops, void *priv)
* dest. cpupool.
*/
static void
-rt_vcpu_insert(const struct scheduler *ops, struct vcpu *vc)
+rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct rt_vcpu *svc = rt_vcpu(vc);
s_time_t now;
spinlock_t *lock;
@@ -889,7 +892,7 @@ rt_vcpu_insert(const struct scheduler *ops, struct vcpu *vc)
BUG_ON( is_idle_vcpu(vc) );
/* This is safe because vc isn't yet being scheduled */
- vc->processor = rt_cpu_pick(ops, vc);
+ vc->processor = rt_cpu_pick(ops, unit);
lock = vcpu_schedule_lock_irq(vc);
@@ -913,8 +916,9 @@ rt_vcpu_insert(const struct scheduler *ops, struct vcpu *vc)
* Remove rt_vcpu svc from the old scheduler in source cpupool.
*/
static void
-rt_vcpu_remove(const struct scheduler *ops, struct vcpu *vc)
+rt_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct rt_vcpu * const svc = rt_vcpu(vc);
struct rt_dom * const sdom = svc->sdom;
spinlock_t *lock;
@@ -1133,8 +1137,9 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
* The lock is already grabbed in schedule.c, no need to lock here
*/
static void
-rt_vcpu_sleep(const struct scheduler *ops, struct vcpu *vc)
+rt_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct rt_vcpu * const svc = rt_vcpu(vc);
BUG_ON( is_idle_vcpu(vc) );
@@ -1248,8 +1253,9 @@ runq_tickle(const struct scheduler *ops, struct rt_vcpu *new)
* TODO: what if these two vcpus belongs to the same domain?
*/
static void
-rt_vcpu_wake(const struct scheduler *ops, struct vcpu *vc)
+rt_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct rt_vcpu * const svc = rt_vcpu(vc);
s_time_t now;
bool_t missed;
@@ -1318,8 +1324,9 @@ rt_vcpu_wake(const struct scheduler *ops, struct vcpu *vc)
* and then pick the highest priority vcpu from runq to run
*/
static void
-rt_context_saved(const struct scheduler *ops, struct vcpu *vc)
+rt_context_saved(const struct scheduler *ops, struct sched_unit *unit)
{
+ struct vcpu *vc = unit->vcpu_list;
struct rt_vcpu *svc = rt_vcpu(vc);
spinlock_t *lock = vcpu_schedule_lock_irq(vc);
@@ -1548,15 +1555,15 @@ static const struct scheduler sched_rtds_def = {
.free_domdata = rt_free_domdata,
.alloc_vdata = rt_alloc_vdata,
.free_vdata = rt_free_vdata,
- .insert_vcpu = rt_vcpu_insert,
- .remove_vcpu = rt_vcpu_remove,
+ .insert_unit = rt_unit_insert,
+ .remove_unit = rt_unit_remove,
.adjust = rt_dom_cntl,
.pick_cpu = rt_cpu_pick,
.do_schedule = rt_schedule,
- .sleep = rt_vcpu_sleep,
- .wake = rt_vcpu_wake,
+ .sleep = rt_unit_sleep,
+ .wake = rt_unit_wake,
.context_saved = rt_context_saved,
};
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 13b5ffc7cf..41af52bc2b 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -87,13 +87,13 @@ sched_idle_switch_sched(struct scheduler *new_ops, unsigned int cpu,
}
static int
-sched_idle_cpu_pick(const struct scheduler *ops, struct vcpu *v)
+sched_idle_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
- return v->processor;
+ return unit->vcpu_list->processor;
}
static void *
-sched_idle_alloc_vdata(const struct scheduler *ops, struct vcpu *v,
+sched_idle_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
void *dd)
{
/* Any non-NULL pointer is fine here. */
@@ -308,9 +308,17 @@ static void sched_spin_unlock_double(spinlock_t *lock1, spinlock_t *lock2,
int sched_init_vcpu(struct vcpu *v, unsigned int processor)
{
struct domain *d = v->domain;
+ struct sched_unit *unit;
v->processor = processor;
+ if ( (unit = xzalloc(struct sched_unit)) == NULL )
+ return 1;
+ unit->vcpu_list = v;
+ unit->unit_id = v->vcpu_id;
+ unit->domain = d;
+ v->sched_unit = unit;
+
/* Initialise the per-vcpu timers. */
spin_lock_init(&v->periodic_timer_lock);
init_timer(&v->periodic_timer, vcpu_periodic_timer_fn,
@@ -320,9 +328,13 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
init_timer(&v->poll_timer, poll_timer_fn,
v, v->processor);
- v->sched_priv = sched_alloc_vdata(dom_scheduler(d), v, d->sched_priv);
+ v->sched_priv = sched_alloc_vdata(dom_scheduler(d), unit, d->sched_priv);
if ( v->sched_priv == NULL )
+ {
+ v->sched_unit = NULL;
+ xfree(unit);
return 1;
+ }
/*
* Initialize affinity settings. The idler, and potentially
@@ -341,7 +353,7 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
}
else
{
- sched_insert_vcpu(dom_scheduler(d), v);
+ sched_insert_unit(dom_scheduler(d), unit);
}
return 0;
@@ -382,7 +394,8 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
for_each_vcpu ( d, v )
{
- vcpu_priv[v->vcpu_id] = sched_alloc_vdata(c->sched, v, domdata);
+ vcpu_priv[v->vcpu_id] = sched_alloc_vdata(c->sched, v->sched_unit,
+ domdata);
if ( vcpu_priv[v->vcpu_id] == NULL )
{
for_each_vcpu ( d, v )
@@ -400,7 +413,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
for_each_vcpu ( d, v )
{
- sched_remove_vcpu(old_ops, v);
+ sched_remove_unit(old_ops, v->sched_unit);
}
d->cpupool = c;
@@ -435,7 +448,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
new_p = cpumask_cycle(new_p, c->cpu_valid);
- sched_insert_vcpu(c->sched, v);
+ sched_insert_unit(c->sched, v->sched_unit);
sched_free_vdata(old_ops, vcpudata);
}
@@ -453,13 +466,17 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
void sched_destroy_vcpu(struct vcpu *v)
{
+ struct sched_unit *unit = v->sched_unit;
+
kill_timer(&v->periodic_timer);
kill_timer(&v->singleshot_timer);
kill_timer(&v->poll_timer);
if ( test_and_clear_bool(v->is_urgent) )
atomic_dec(&per_cpu(schedule_data, v->processor).urgent_count);
- sched_remove_vcpu(vcpu_scheduler(v), v);
+ sched_remove_unit(vcpu_scheduler(v), unit);
sched_free_vdata(vcpu_scheduler(v), v->sched_priv);
+ v->sched_unit = NULL;
+ xfree(unit);
}
int sched_init_domain(struct domain *d, int poolid)
@@ -510,7 +527,7 @@ void vcpu_sleep_nosync_locked(struct vcpu *v)
if ( v->runstate.state == RUNSTATE_runnable )
vcpu_runstate_change(v, RUNSTATE_offline, NOW());
- sched_sleep(vcpu_scheduler(v), v);
+ sched_sleep(vcpu_scheduler(v), v->sched_unit);
}
}
@@ -551,7 +568,7 @@ void vcpu_wake(struct vcpu *v)
{
if ( v->runstate.state >= RUNSTATE_blocked )
vcpu_runstate_change(v, RUNSTATE_runnable, NOW());
- sched_wake(vcpu_scheduler(v), v);
+ sched_wake(vcpu_scheduler(v), v->sched_unit);
}
else if ( !(v->pause_flags & VPF_blocked) )
{
@@ -606,7 +623,7 @@ static void vcpu_move_locked(struct vcpu *v, unsigned int new_cpu)
* Actual CPU switch to new CPU. This is safe because the lock
* pointer can't change while the current lock is held.
*/
- sched_migrate(vcpu_scheduler(v), v, new_cpu);
+ sched_migrate(vcpu_scheduler(v), v->sched_unit, new_cpu);
}
/*
@@ -684,7 +701,7 @@ static void vcpu_migrate_finish(struct vcpu *v)
break;
/* Select a new CPU. */
- new_cpu = sched_pick_cpu(vcpu_scheduler(v), v);
+ new_cpu = sched_pick_cpu(vcpu_scheduler(v), v->sched_unit);
if ( (new_lock == per_cpu(schedule_data, new_cpu).schedule_lock) &&
cpumask_test_cpu(new_cpu, v->domain->cpupool->cpu_valid) )
break;
@@ -776,7 +793,7 @@ void restore_vcpu_affinity(struct domain *d)
/* v->processor might have changed, so reacquire the lock. */
lock = vcpu_schedule_lock_irq(v);
- v->processor = sched_pick_cpu(vcpu_scheduler(v), v);
+ v->processor = sched_pick_cpu(vcpu_scheduler(v), v->sched_unit);
spin_unlock_irq(lock);
if ( old_cpu != v->processor )
@@ -888,7 +905,7 @@ static int cpu_disable_scheduler_check(unsigned int cpu)
void sched_set_affinity(
struct vcpu *v, const cpumask_t *hard, const cpumask_t *soft)
{
- sched_adjust_affinity(dom_scheduler(v->domain), v, hard, soft);
+ sched_adjust_affinity(dom_scheduler(v->domain), v->sched_unit, hard, soft);
if ( hard )
cpumask_copy(v->cpu_hard_affinity, hard);
@@ -1063,7 +1080,7 @@ long vcpu_yield(void)
struct vcpu * v=current;
spinlock_t *lock = vcpu_schedule_lock_irq(v);
- sched_yield(vcpu_scheduler(v), v);
+ sched_yield(vcpu_scheduler(v), v->sched_unit);
vcpu_schedule_unlock_irq(lock, v);
SCHED_STAT_CRANK(vcpu_yield);
@@ -1612,7 +1629,7 @@ void context_saved(struct vcpu *prev)
/* Check for migration request /after/ clearing running flag. */
smp_mb();
- sched_context_saved(vcpu_scheduler(prev), prev);
+ sched_context_saved(vcpu_scheduler(prev), prev->sched_unit);
vcpu_migrate_finish(prev);
}
@@ -1888,7 +1905,8 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c)
ppriv = sched_alloc_pdata(new_ops, cpu);
if ( IS_ERR(ppriv) )
return PTR_ERR(ppriv);
- vpriv = sched_alloc_vdata(new_ops, idle, idle->domain->sched_priv);
+ vpriv = sched_alloc_vdata(new_ops, idle->sched_unit,
+ idle->domain->sched_priv);
if ( vpriv == NULL )
{
sched_free_pdata(new_ops, ppriv, cpu);
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index dc255b064b..0af89fbd02 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -141,8 +141,8 @@ struct scheduler {
void (*deinit) (struct scheduler *);
void (*free_vdata) (const struct scheduler *, void *);
- void * (*alloc_vdata) (const struct scheduler *, struct vcpu *,
- void *);
+ void * (*alloc_vdata) (const struct scheduler *,
+ struct sched_unit *, void *);
void (*free_pdata) (const struct scheduler *, void *, int);
void * (*alloc_pdata) (const struct scheduler *, int);
void (*init_pdata) (const struct scheduler *, void *, int);
@@ -156,24 +156,32 @@ struct scheduler {
spinlock_t * (*switch_sched) (struct scheduler *, unsigned int,
void *, void *);
- /* Activate / deactivate vcpus in a cpu pool */
- void (*insert_vcpu) (const struct scheduler *, struct vcpu *);
- void (*remove_vcpu) (const struct scheduler *, struct vcpu *);
-
- void (*sleep) (const struct scheduler *, struct vcpu *);
- void (*wake) (const struct scheduler *, struct vcpu *);
- void (*yield) (const struct scheduler *, struct vcpu *);
- void (*context_saved) (const struct scheduler *, struct vcpu *);
+ /* Activate / deactivate units in a cpu pool */
+ void (*insert_unit) (const struct scheduler *,
+ struct sched_unit *);
+ void (*remove_unit) (const struct scheduler *,
+ struct sched_unit *);
+
+ void (*sleep) (const struct scheduler *,
+ struct sched_unit *);
+ void (*wake) (const struct scheduler *,
+ struct sched_unit *);
+ void (*yield) (const struct scheduler *,
+ struct sched_unit *);
+ void (*context_saved) (const struct scheduler *,
+ struct sched_unit *);
struct task_slice (*do_schedule) (const struct scheduler *, s_time_t,
bool_t tasklet_work_scheduled);
- int (*pick_cpu) (const struct scheduler *, struct vcpu *);
- void (*migrate) (const struct scheduler *, struct vcpu *,
- unsigned int);
+ int (*pick_cpu) (const struct scheduler *,
+ const struct sched_unit *);
+ void (*migrate) (const struct scheduler *,
+ struct sched_unit *, unsigned int);
int (*adjust) (const struct scheduler *, struct domain *,
struct xen_domctl_scheduler_op *);
- void (*adjust_affinity)(const struct scheduler *, struct vcpu *,
+ void (*adjust_affinity)(const struct scheduler *,
+ struct sched_unit *,
const struct cpumask *,
const struct cpumask *);
int (*adjust_global) (const struct scheduler *,
@@ -267,10 +275,10 @@ static inline void sched_deinit_pdata(const struct scheduler *s, void *data,
s->deinit_pdata(s, data, cpu);
}
-static inline void *sched_alloc_vdata(const struct scheduler *s, struct vcpu *v,
- void *dom_data)
+static inline void *sched_alloc_vdata(const struct scheduler *s,
+ struct sched_unit *unit, void *dom_data)
{
- return s->alloc_vdata(s, v, dom_data);
+ return s->alloc_vdata(s, unit, dom_data);
}
static inline void sched_free_vdata(const struct scheduler *s, void *data)
@@ -278,64 +286,70 @@ static inline void sched_free_vdata(const struct scheduler *s, void *data)
s->free_vdata(s, data);
}
-static inline void sched_insert_vcpu(const struct scheduler *s, struct vcpu *v)
+static inline void sched_insert_unit(const struct scheduler *s,
+ struct sched_unit *unit)
{
- if ( s->insert_vcpu )
- s->insert_vcpu(s, v);
+ if ( s->insert_unit )
+ s->insert_unit(s, unit);
}
-static inline void sched_remove_vcpu(const struct scheduler *s, struct vcpu *v)
+static inline void sched_remove_unit(const struct scheduler *s,
+ struct sched_unit *unit)
{
- if ( s->remove_vcpu )
- s->remove_vcpu(s, v);
+ if ( s->remove_unit )
+ s->remove_unit(s, unit);
}
-static inline void sched_sleep(const struct scheduler *s, struct vcpu *v)
+static inline void sched_sleep(const struct scheduler *s,
+ struct sched_unit *unit)
{
if ( s->sleep )
- s->sleep(s, v);
+ s->sleep(s, unit);
}
-static inline void sched_wake(const struct scheduler *s, struct vcpu *v)
+static inline void sched_wake(const struct scheduler *s,
+ struct sched_unit *unit)
{
if ( s->wake )
- s->wake(s, v);
+ s->wake(s, unit);
}
-static inline void sched_yield(const struct scheduler *s, struct vcpu *v)
+static inline void sched_yield(const struct scheduler *s,
+ struct sched_unit *unit)
{
if ( s->yield )
- s->yield(s, v);
+ s->yield(s, unit);
}
static inline void sched_context_saved(const struct scheduler *s,
- struct vcpu *v)
+ struct sched_unit *unit)
{
if ( s->context_saved )
- s->context_saved(s, v);
+ s->context_saved(s, unit);
}
-static inline void sched_migrate(const struct scheduler *s, struct vcpu *v,
- unsigned int cpu)
+static inline void sched_migrate(const struct scheduler *s,
+ struct sched_unit *unit, unsigned int cpu)
{
if ( s->migrate )
- s->migrate(s, v, cpu);
+ s->migrate(s, unit, cpu);
else
- v->processor = cpu;
+ unit->vcpu_list->processor = cpu;
}
-static inline int sched_pick_cpu(const struct scheduler *s, struct vcpu *v)
+static inline int sched_pick_cpu(const struct scheduler *s,
+ const struct sched_unit *unit)
{
- return s->pick_cpu(s, v);
+ return s->pick_cpu(s, unit);
}
static inline void sched_adjust_affinity(const struct scheduler *s,
- struct vcpu *v,
+ struct sched_unit *unit,
const cpumask_t *hard,
const cpumask_t *soft)
{
if ( s->adjust_affinity )
- s->adjust_affinity(s, v, hard, soft);
+ s->adjust_affinity(s, unit, hard, soft);
}
static inline int sched_adjust_dom(const struct scheduler *s, struct domain *d,
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 40097ff334..386549ebbb 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -161,6 +161,7 @@ struct vcpu
struct timer poll_timer; /* timeout for SCHEDOP_poll */
+ struct sched_unit *sched_unit;
void *sched_priv; /* scheduler-specific data */
struct vcpu_runstate_info runstate;
@@ -273,6 +274,12 @@ struct vcpu
struct arch_vcpu arch;
};
+struct sched_unit {
+ struct domain *domain;
+ struct vcpu *vcpu_list;
+ unsigned int unit_id;
+};
+
/* Per-domain lock can be recursively acquired in fault handlers. */
#define domain_lock(d) spin_lock_recursive(&(d)->domain_lock)
#define domain_unlock(d) spin_unlock_recursive(&(d)->domain_lock)
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 02/47] xen/sched: move per-vcpu scheduler private data pointer to sched_unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 01/47] xen/sched: use new sched_unit instead of vcpu in scheduler interfaces Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 03/47] xen/sched: build a linked list of struct sched_unit Juergen Gross
` (46 subsequent siblings)
48 siblings, 0 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Robert VanVossen, Dario Faggioli, Julien Grall, Josh Whitehead,
Meng Xu, Jan Beulich
This prepares making the different schedulers vcpu agnostic.
Note that some scheduler specific accessor function are misnamed after
this patch. This will be corrected in later patches.
Signed-off-by: Juergen Gross <jgross@suse.com>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
---
xen/common/sched_arinc653.c | 4 ++--
xen/common/sched_credit.c | 6 +++---
xen/common/sched_credit2.c | 10 +++++-----
xen/common/sched_null.c | 4 ++--
xen/common/sched_rt.c | 4 ++--
xen/common/schedule.c | 14 +++++++-------
xen/include/xen/sched.h | 2 +-
7 files changed, 22 insertions(+), 22 deletions(-)
diff --git a/xen/common/sched_arinc653.c b/xen/common/sched_arinc653.c
index e8b13a0022..cdf5c2cc97 100644
--- a/xen/common/sched_arinc653.c
+++ b/xen/common/sched_arinc653.c
@@ -53,7 +53,7 @@
* Return a pointer to the ARINC 653-specific scheduler data information
* associated with the given VCPU (vc)
*/
-#define AVCPU(vc) ((arinc653_vcpu_t *)(vc)->sched_priv)
+#define AVCPU(vc) ((arinc653_vcpu_t *)(vc)->sched_unit->priv)
/**
* Return the global scheduler private data given the scheduler ops pointer
@@ -647,7 +647,7 @@ a653_switch_sched(struct scheduler *new_ops, unsigned int cpu,
ASSERT(!pdata && svc && is_idle_vcpu(svc->vc));
- idle_vcpu[cpu]->sched_priv = vdata;
+ idle_vcpu[cpu]->sched_unit->priv = vdata;
return &sd->_lock;
}
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index 94d733dcb5..f4371d7c5e 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -83,7 +83,7 @@
((struct csched_private *)((_ops)->sched_data))
#define CSCHED_PCPU(_c) \
((struct csched_pcpu *)per_cpu(schedule_data, _c).sched_priv)
-#define CSCHED_VCPU(_vcpu) ((struct csched_vcpu *) (_vcpu)->sched_priv)
+#define CSCHED_VCPU(_vcpu) ((struct csched_vcpu *) (_vcpu)->sched_unit->priv)
#define CSCHED_DOM(_dom) ((struct csched_dom *) (_dom)->sched_priv)
#define RUNQ(_cpu) (&(CSCHED_PCPU(_cpu)->runq))
@@ -634,7 +634,7 @@ csched_switch_sched(struct scheduler *new_ops, unsigned int cpu,
ASSERT(svc && is_idle_vcpu(svc->vcpu));
- idle_vcpu[cpu]->sched_priv = vdata;
+ idle_vcpu[cpu]->sched_unit->priv = vdata;
/*
* We are holding the runqueue lock already (it's been taken in
@@ -1017,7 +1017,7 @@ static void
csched_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched_vcpu *svc = vc->sched_priv;
+ struct csched_vcpu *svc = unit->priv;
spinlock_t *lock;
BUG_ON( is_idle_vcpu(vc) );
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 1973dbddcc..2852a220c4 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -573,7 +573,7 @@ static inline struct csched2_pcpu *csched2_pcpu(unsigned int cpu)
static inline struct csched2_vcpu *csched2_vcpu(const struct vcpu *v)
{
- return v->sched_priv;
+ return v->sched_unit->priv;
}
static inline struct csched2_dom *csched2_dom(const struct domain *d)
@@ -971,7 +971,7 @@ _runq_assign(struct csched2_vcpu *svc, struct csched2_runqueue_data *rqd)
static void
runq_assign(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched2_vcpu *svc = vc->sched_priv;
+ struct csched2_vcpu *svc = vc->sched_unit->priv;
ASSERT(svc->rqd == NULL);
@@ -998,7 +998,7 @@ _runq_deassign(struct csched2_vcpu *svc)
static void
runq_deassign(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched2_vcpu *svc = vc->sched_priv;
+ struct csched2_vcpu *svc = vc->sched_unit->priv;
ASSERT(svc->rqd == c2rqd(ops, vc->processor));
@@ -3109,7 +3109,7 @@ static void
csched2_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched2_vcpu *svc = vc->sched_priv;
+ struct csched2_vcpu *svc = unit->priv;
struct csched2_dom * const sdom = svc->sdom;
spinlock_t *lock;
@@ -3891,7 +3891,7 @@ csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu,
ASSERT(!local_irq_is_enabled());
write_lock(&prv->lock);
- idle_vcpu[cpu]->sched_priv = vdata;
+ idle_vcpu[cpu]->sched_unit->priv = vdata;
rqi = init_pdata(prv, pdata, cpu);
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index a5a9ce2d57..bb9fed8aab 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -116,7 +116,7 @@ static inline struct null_private *null_priv(const struct scheduler *ops)
static inline struct null_vcpu *null_vcpu(const struct vcpu *v)
{
- return v->sched_priv;
+ return v->sched_unit->priv;
}
static inline bool vcpu_check_affinity(struct vcpu *v, unsigned int cpu,
@@ -422,7 +422,7 @@ static spinlock_t *null_switch_sched(struct scheduler *new_ops,
ASSERT(nvc && is_idle_vcpu(nvc->vcpu));
- idle_vcpu[cpu]->sched_priv = vdata;
+ idle_vcpu[cpu]->sched_unit->priv = vdata;
/*
* We are holding the runqueue lock already (it's been taken in
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index 0f5e0ebcc1..dd51613845 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -235,7 +235,7 @@ static inline struct rt_private *rt_priv(const struct scheduler *ops)
static inline struct rt_vcpu *rt_vcpu(const struct vcpu *vcpu)
{
- return vcpu->sched_priv;
+ return vcpu->sched_unit->priv;
}
static inline struct list_head *rt_runq(const struct scheduler *ops)
@@ -760,7 +760,7 @@ rt_switch_sched(struct scheduler *new_ops, unsigned int cpu,
dprintk(XENLOG_DEBUG, "RTDS: timer initialized on cpu %u\n", cpu);
}
- idle_vcpu[cpu]->sched_priv = vdata;
+ idle_vcpu[cpu]->sched_unit->priv = vdata;
return &prv->lock;
}
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 41af52bc2b..88b66f808c 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -81,7 +81,7 @@ static spinlock_t *
sched_idle_switch_sched(struct scheduler *new_ops, unsigned int cpu,
void *pdata, void *vdata)
{
- idle_vcpu[cpu]->sched_priv = NULL;
+ idle_vcpu[cpu]->sched_unit->priv = NULL;
return &sched_free_cpu_lock;
}
@@ -328,8 +328,8 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
init_timer(&v->poll_timer, poll_timer_fn,
v, v->processor);
- v->sched_priv = sched_alloc_vdata(dom_scheduler(d), unit, d->sched_priv);
- if ( v->sched_priv == NULL )
+ unit->priv = sched_alloc_vdata(dom_scheduler(d), unit, d->sched_priv);
+ if ( unit->priv == NULL )
{
v->sched_unit = NULL;
xfree(unit);
@@ -424,7 +424,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
{
spinlock_t *lock;
- vcpudata = v->sched_priv;
+ vcpudata = v->sched_unit->priv;
migrate_timer(&v->periodic_timer, new_p);
migrate_timer(&v->singleshot_timer, new_p);
@@ -442,7 +442,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
*/
spin_unlock_irq(lock);
- v->sched_priv = vcpu_priv[v->vcpu_id];
+ v->sched_unit->priv = vcpu_priv[v->vcpu_id];
if ( !d->is_dying )
sched_move_irqs(v);
@@ -474,7 +474,7 @@ void sched_destroy_vcpu(struct vcpu *v)
if ( test_and_clear_bool(v->is_urgent) )
atomic_dec(&per_cpu(schedule_data, v->processor).urgent_count);
sched_remove_unit(vcpu_scheduler(v), unit);
- sched_free_vdata(vcpu_scheduler(v), v->sched_priv);
+ sched_free_vdata(vcpu_scheduler(v), unit->priv);
v->sched_unit = NULL;
xfree(unit);
}
@@ -1929,7 +1929,7 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c)
*/
old_lock = pcpu_schedule_lock_irqsave(cpu, &flags);
- vpriv_old = idle->sched_priv;
+ vpriv_old = idle->sched_unit->priv;
ppriv_old = sd->sched_priv;
new_lock = sched_switch_sched(new_ops, cpu, ppriv, vpriv);
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 386549ebbb..1f58b72341 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -162,7 +162,6 @@ struct vcpu
struct timer poll_timer; /* timeout for SCHEDOP_poll */
struct sched_unit *sched_unit;
- void *sched_priv; /* scheduler-specific data */
struct vcpu_runstate_info runstate;
#ifndef CONFIG_COMPAT
@@ -277,6 +276,7 @@ struct vcpu
struct sched_unit {
struct domain *domain;
struct vcpu *vcpu_list;
+ void *priv; /* scheduler private data */
unsigned int unit_id;
};
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 03/47] xen/sched: build a linked list of struct sched_unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 01/47] xen/sched: use new sched_unit instead of vcpu in scheduler interfaces Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 02/47] xen/sched: move per-vcpu scheduler private data pointer to sched_unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 04/47] xen/sched: introduce struct sched_resource Juergen Gross
` (45 subsequent siblings)
48 siblings, 0 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
In order to make it easy to iterate over sched_unit elements of a
domain, build a single linked list and add an iterator for it. The new
list is guarded by the same mechanisms as the vcpu linked list as it
is modified only via vcpu_create() or vcpu_destroy().
For completeness add another iterator for_each_sched_unit_vcpu() which
will iterate over all vcpus of a sched_unit (right now only one). This
will be needed later for larger scheduling granularity (e.g. cores).
Signed-off-by: Juergen Gross <jgross@suse.com>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
---
V2:
- add comment (Dario Faggioli)
---
xen/common/schedule.c | 60 +++++++++++++++++++++++++++++++++++++++++--------
xen/include/xen/sched.h | 14 ++++++++++++
2 files changed, 65 insertions(+), 9 deletions(-)
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 88b66f808c..614df9d226 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -305,20 +305,64 @@ static void sched_spin_unlock_double(spinlock_t *lock1, spinlock_t *lock2,
spin_unlock_irqrestore(lock1, flags);
}
-int sched_init_vcpu(struct vcpu *v, unsigned int processor)
+static void sched_free_unit(struct sched_unit *unit)
{
- struct domain *d = v->domain;
- struct sched_unit *unit;
+ struct sched_unit *prev_unit;
+ struct domain *d = unit->domain;
- v->processor = processor;
+ if ( d->sched_unit_list == unit )
+ d->sched_unit_list = unit->next_in_list;
+ else
+ {
+ for_each_sched_unit ( d, prev_unit )
+ {
+ if ( prev_unit->next_in_list == unit )
+ {
+ prev_unit->next_in_list = unit->next_in_list;
+ break;
+ }
+ }
+ }
+
+ unit->vcpu_list->sched_unit = NULL;
+ xfree(unit);
+}
+
+static struct sched_unit *sched_alloc_unit(struct vcpu *v)
+{
+ struct sched_unit *unit, **prev_unit;
+ struct domain *d = v->domain;
if ( (unit = xzalloc(struct sched_unit)) == NULL )
- return 1;
+ return NULL;
+
unit->vcpu_list = v;
unit->unit_id = v->vcpu_id;
unit->domain = d;
v->sched_unit = unit;
+ for ( prev_unit = &d->sched_unit_list; *prev_unit;
+ prev_unit = &(*prev_unit)->next_in_list )
+ if ( (*prev_unit)->next_in_list &&
+ (*prev_unit)->next_in_list->unit_id > unit->unit_id )
+ break;
+
+ unit->next_in_list = *prev_unit;
+ *prev_unit = unit;
+
+ return unit;
+}
+
+int sched_init_vcpu(struct vcpu *v, unsigned int processor)
+{
+ struct domain *d = v->domain;
+ struct sched_unit *unit;
+
+ v->processor = processor;
+
+ if ( (unit = sched_alloc_unit(v)) == NULL )
+ return 1;
+
/* Initialise the per-vcpu timers. */
spin_lock_init(&v->periodic_timer_lock);
init_timer(&v->periodic_timer, vcpu_periodic_timer_fn,
@@ -331,8 +375,7 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
unit->priv = sched_alloc_vdata(dom_scheduler(d), unit, d->sched_priv);
if ( unit->priv == NULL )
{
- v->sched_unit = NULL;
- xfree(unit);
+ sched_free_unit(unit);
return 1;
}
@@ -475,8 +518,7 @@ void sched_destroy_vcpu(struct vcpu *v)
atomic_dec(&per_cpu(schedule_data, v->processor).urgent_count);
sched_remove_unit(vcpu_scheduler(v), unit);
sched_free_vdata(vcpu_scheduler(v), unit->priv);
- v->sched_unit = NULL;
- xfree(unit);
+ sched_free_unit(unit);
}
int sched_init_domain(struct domain *d, int poolid)
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 1f58b72341..89038337b4 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -277,9 +277,22 @@ struct sched_unit {
struct domain *domain;
struct vcpu *vcpu_list;
void *priv; /* scheduler private data */
+ struct sched_unit *next_in_list;
unsigned int unit_id;
};
+#define for_each_sched_unit(d, e) \
+ for ( (e) = (d)->sched_unit_list; (e) != NULL; (e) = (e)->next_in_list )
+
+/*
+ * All vcpus of a domain are in a single linked list with unit->vcpu_list
+ * pointing to the first vcpu of the unit. The loop must be terminated when
+ * a vcpu is hit not being part of the unit to loop over.
+ */
+#define for_each_sched_unit_vcpu(i, v) \
+ for ( (v) = (i)->vcpu_list; (v) != NULL && (v)->sched_unit == (i); \
+ (v) = (v)->next_in_list )
+
/* Per-domain lock can be recursively acquired in fault handlers. */
#define domain_lock(d) spin_lock_recursive(&(d)->domain_lock)
#define domain_unlock(d) spin_unlock_recursive(&(d)->domain_lock)
@@ -333,6 +346,7 @@ struct domain
/* Scheduling. */
void *sched_priv; /* scheduler-specific data */
+ struct sched_unit *sched_unit_list;
struct cpupool *cpupool;
struct domain *next_in_list;
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 04/47] xen/sched: introduce struct sched_resource
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (2 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 03/47] xen/sched: build a linked list of struct sched_unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 05/47] xen/sched: let pick_cpu return a scheduler resource Juergen Gross
` (44 subsequent siblings)
48 siblings, 0 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Meng Xu, Jan Beulich
Add a scheduling abstraction layer between physical processors and the
schedulers by introducing a struct sched_resource. Each scheduler unit
running is active on such a scheduler resource. For the time being
there is one struct sched_resource per cpu, but in future there might
be one for each core or socket only.
Signed-off-by: Juergen Gross <jgross@suse.com>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
---
V1:
- add accessor functions
- use DEFINE_PER_CPU_READ_MOSTLY (Dario Faggioli)
V3:
- don't pre-define struct sched_resource in sched.h (Jan Beulich)
- rename res->processor to res->master_cpu (Jan Beulich)
---
xen/common/sched_credit.c | 2 ++
xen/common/sched_credit2.c | 7 +++++++
xen/common/sched_null.c | 3 +++
xen/common/sched_rt.c | 2 ++
xen/common/schedule.c | 19 ++++++++++++++++++-
xen/include/xen/sched-if.h | 18 ++++++++++++++++++
xen/include/xen/sched.h | 1 +
7 files changed, 51 insertions(+), 1 deletion(-)
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index f4371d7c5e..2bc7fa9220 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -1026,6 +1026,7 @@ csched_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
lock = vcpu_schedule_lock_irq(vc);
vc->processor = csched_cpu_pick(ops, unit);
+ unit->res = get_sched_res(vc->processor);
spin_unlock_irq(lock);
@@ -1662,6 +1663,7 @@ csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
WARN_ON(vc->is_urgent);
runq_remove(speer);
vc->processor = cpu;
+ vc->sched_unit->res = get_sched_res(cpu);
/*
* speer will start executing directly on cpu, without having to
* go through runq_insert(). So we must update the runnable count
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 2852a220c4..200de63bee 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -2520,6 +2520,7 @@ static void migrate(const struct scheduler *ops,
&trqd->active);
svc->vcpu->processor = cpumask_cycle(trqd->pick_bias,
cpumask_scratch_cpu(cpu));
+ svc->vcpu->sched_unit->res = get_sched_res(svc->vcpu->processor);
trqd->pick_bias = svc->vcpu->processor;
ASSERT(svc->vcpu->processor < nr_cpu_ids);
@@ -2775,6 +2776,7 @@ csched2_unit_migrate(
}
_runq_deassign(svc);
vc->processor = new_cpu;
+ unit->res = get_sched_res(new_cpu);
return;
}
@@ -2795,7 +2797,10 @@ csched2_unit_migrate(
if ( trqd != svc->rqd )
migrate(ops, svc, trqd, now);
else
+ {
vc->processor = new_cpu;
+ unit->res = get_sched_res(new_cpu);
+ }
}
static int
@@ -3120,6 +3125,7 @@ csched2_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
lock = vcpu_schedule_lock_irq(vc);
vc->processor = csched2_cpu_pick(ops, unit);
+ unit->res = get_sched_res(vc->processor);
spin_unlock_irq(lock);
@@ -3597,6 +3603,7 @@ csched2_schedule(
{
snext->credit += CSCHED2_MIGRATE_COMPENSATION;
snext->vcpu->processor = cpu;
+ snext->vcpu->sched_unit->res = get_sched_res(cpu);
SCHED_STAT_CRANK(migrated);
ret.migrated = 1;
}
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index bb9fed8aab..c30fe2e443 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -337,6 +337,7 @@ static void vcpu_assign(struct null_private *prv, struct vcpu *v,
per_cpu(npc, cpu).vcpu = v;
v->processor = cpu;
+ v->sched_unit->res = get_sched_res(cpu);
cpumask_clear_cpu(cpu, &prv->cpus_free);
dprintk(XENLOG_G_INFO, "%d <-- %pv\n", cpu, v);
@@ -457,6 +458,7 @@ static void null_unit_insert(const struct scheduler *ops,
retry:
cpu = v->processor = pick_cpu(prv, v);
+ unit->res = get_sched_res(cpu);
spin_unlock(lock);
@@ -749,6 +751,7 @@ static void null_unit_migrate(const struct scheduler *ops,
*/
out:
v->processor = new_cpu;
+ unit->res = get_sched_res(new_cpu);
}
#ifndef NDEBUG
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index dd51613845..3ba76f1c4a 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -893,6 +893,7 @@ rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
/* This is safe because vc isn't yet being scheduled */
vc->processor = rt_cpu_pick(ops, unit);
+ unit->res = get_sched_res(vc->processor);
lock = vcpu_schedule_lock_irq(vc);
@@ -1123,6 +1124,7 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
if ( snext->vcpu->processor != cpu )
{
snext->vcpu->processor = cpu;
+ snext->vcpu->sched_unit->res = get_sched_res(cpu);
ret.migrated = 1;
}
ret.time = snext->cur_budget; /* invoke the scheduler next time */
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 614df9d226..2bf7966476 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -67,6 +67,7 @@ static void poll_timer_fn(void *data);
/* This is global for now so that private implementations can reach it */
DEFINE_PER_CPU(struct schedule_data, schedule_data);
DEFINE_PER_CPU(struct scheduler *, scheduler);
+DEFINE_PER_CPU_READ_MOSTLY(struct sched_resource *, sched_res);
/* Scratch space for cpumasks. */
DEFINE_PER_CPU(cpumask_t, cpumask_scratch);
@@ -89,7 +90,7 @@ sched_idle_switch_sched(struct scheduler *new_ops, unsigned int cpu,
static int
sched_idle_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
- return unit->vcpu_list->processor;
+ return unit->res->master_cpu;
}
static void *
@@ -363,6 +364,7 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
if ( (unit = sched_alloc_unit(v)) == NULL )
return 1;
+ unit->res = get_sched_res(processor);
/* Initialise the per-vcpu timers. */
spin_lock_init(&v->periodic_timer_lock);
init_timer(&v->periodic_timer, vcpu_periodic_timer_fn,
@@ -478,6 +480,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
sched_set_affinity(v, &cpumask_all, &cpumask_all);
v->processor = new_p;
+ v->sched_unit->res = get_sched_res(new_p);
/*
* With v->processor modified we must not
* - make any further changes assuming we hold the scheduler lock,
@@ -830,12 +833,14 @@ void restore_vcpu_affinity(struct domain *d)
}
v->processor = cpumask_any(cpumask_scratch_cpu(cpu));
+ v->sched_unit->res = get_sched_res(v->processor);
spin_unlock_irq(lock);
/* v->processor might have changed, so reacquire the lock. */
lock = vcpu_schedule_lock_irq(v);
v->processor = sched_pick_cpu(vcpu_scheduler(v), v->sched_unit);
+ v->sched_unit->res = get_sched_res(v->processor);
spin_unlock_irq(lock);
if ( old_cpu != v->processor )
@@ -1709,6 +1714,13 @@ static void poll_timer_fn(void *data)
static int cpu_schedule_up(unsigned int cpu)
{
struct schedule_data *sd = &per_cpu(schedule_data, cpu);
+ struct sched_resource *res;
+
+ res = xzalloc(struct sched_resource);
+ if ( res == NULL )
+ return -ENOMEM;
+ res->master_cpu = cpu;
+ set_sched_res(cpu, res);
per_cpu(scheduler, cpu) = &sched_idle_ops;
spin_lock_init(&sd->_lock);
@@ -1722,6 +1734,8 @@ static int cpu_schedule_up(unsigned int cpu)
if ( idle_vcpu[cpu] == NULL )
vcpu_create(idle_vcpu[0]->domain, cpu, cpu);
+ else
+ idle_vcpu[cpu]->sched_unit->res = res;
if ( idle_vcpu[cpu] == NULL )
return -ENOMEM;
@@ -1744,6 +1758,9 @@ static void cpu_schedule_down(unsigned int cpu)
struct schedule_data *sd = &per_cpu(schedule_data, cpu);
kill_timer(&sd->s_timer);
+
+ set_sched_res(cpu, NULL);
+ xfree(sd);
}
void sched_rm_cpu(unsigned int cpu)
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 0af89fbd02..b9e2920c66 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -44,9 +44,24 @@ struct schedule_data {
#define curr_on_cpu(c) (per_cpu(schedule_data, c).curr)
+struct sched_resource {
+ unsigned int master_cpu; /* Cpu with lowest id in scheduling resource. */
+};
+
DECLARE_PER_CPU(struct schedule_data, schedule_data);
DECLARE_PER_CPU(struct scheduler *, scheduler);
DECLARE_PER_CPU(struct cpupool *, cpupool);
+DECLARE_PER_CPU(struct sched_resource *, sched_res);
+
+static inline struct sched_resource *get_sched_res(unsigned int cpu)
+{
+ return per_cpu(sched_res, cpu);
+}
+
+static inline void set_sched_res(unsigned int cpu, struct sched_resource *res)
+{
+ per_cpu(sched_res, cpu) = res;
+}
/*
* Scratch space, for avoiding having too many cpumask_t on the stack.
@@ -334,7 +349,10 @@ static inline void sched_migrate(const struct scheduler *s,
if ( s->migrate )
s->migrate(s, unit, cpu);
else
+ {
unit->vcpu_list->processor = cpu;
+ unit->res = get_sched_res(cpu);
+ }
}
static inline int sched_pick_cpu(const struct scheduler *s,
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 89038337b4..999e43e8cc 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -278,6 +278,7 @@ struct sched_unit {
struct vcpu *vcpu_list;
void *priv; /* scheduler private data */
struct sched_unit *next_in_list;
+ struct sched_resource *res;
unsigned int unit_id;
};
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 05/47] xen/sched: let pick_cpu return a scheduler resource
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (3 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 04/47] xen/sched: introduce struct sched_resource Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 06/47] xen/sched: switch schedule_data.curr to point at sched_unit Juergen Gross
` (43 subsequent siblings)
48 siblings, 0 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Robert VanVossen, Dario Faggioli, Julien Grall, Josh Whitehead,
Meng Xu, Jan Beulich
Instead of returning a physical cpu number let pick_cpu() return a
scheduler resource instead. Rename pick_cpu() to pick_resource() to
reflect that change.
Signed-off-by: Juergen Gross <jgross@suse.com>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
---
V3:
- style fix (Jan Beulich)
---
xen/common/sched_arinc653.c | 13 +++++++------
xen/common/sched_credit.c | 16 ++++++++--------
xen/common/sched_credit2.c | 22 +++++++++++-----------
xen/common/sched_null.c | 23 ++++++++++++-----------
xen/common/sched_rt.c | 18 +++++++++---------
xen/common/schedule.c | 18 ++++++++++--------
xen/include/xen/perfc_defn.h | 2 +-
xen/include/xen/sched-if.h | 10 +++++-----
8 files changed, 63 insertions(+), 59 deletions(-)
diff --git a/xen/common/sched_arinc653.c b/xen/common/sched_arinc653.c
index cdf5c2cc97..9754aaa503 100644
--- a/xen/common/sched_arinc653.c
+++ b/xen/common/sched_arinc653.c
@@ -601,15 +601,16 @@ a653sched_do_schedule(
}
/**
- * Xen scheduler callback function to select a CPU for the VCPU to run on
+ * Xen scheduler callback function to select a resource for the VCPU to run on
*
* @param ops Pointer to this instance of the scheduler structure
* @param unit Pointer to struct sched_unit
*
- * @return Number of selected physical CPU
+ * @return Scheduler resource to run on
*/
-static int
-a653sched_pick_cpu(const struct scheduler *ops, const struct sched_unit *unit)
+static struct sched_resource *
+a653sched_pick_resource(const struct scheduler *ops,
+ const struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
cpumask_t *online;
@@ -627,7 +628,7 @@ a653sched_pick_cpu(const struct scheduler *ops, const struct sched_unit *unit)
|| (cpu >= nr_cpu_ids) )
cpu = vc->processor;
- return cpu;
+ return get_sched_res(cpu);
}
/**
@@ -720,7 +721,7 @@ static const struct scheduler sched_arinc653_def = {
.do_schedule = a653sched_do_schedule,
- .pick_cpu = a653sched_pick_cpu,
+ .pick_resource = a653sched_pick_resource,
.switch_sched = a653_switch_sched,
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index 2bc7fa9220..b34cc32ce0 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -853,8 +853,8 @@ _csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc, bool_t commit)
return cpu;
}
-static int
-csched_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
+static struct sched_resource *
+csched_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
struct csched_vcpu *svc = CSCHED_VCPU(vc);
@@ -867,7 +867,7 @@ csched_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
* get boosted, which we don't deserve as we are "only" migrating.
*/
set_bit(CSCHED_FLAG_VCPU_MIGRATING, &svc->flags);
- return _csched_cpu_pick(ops, vc, 1);
+ return get_sched_res(_csched_cpu_pick(ops, vc, 1));
}
static inline void
@@ -967,7 +967,7 @@ csched_vcpu_acct(struct csched_private *prv, unsigned int cpu)
/*
* If it's been active a while, check if we'd be better off
* migrating it to run elsewhere (see multi-core and multi-thread
- * support in csched_cpu_pick()).
+ * support in csched_res_pick()).
*/
new_cpu = _csched_cpu_pick(ops, current, 0);
@@ -1022,11 +1022,11 @@ csched_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
BUG_ON( is_idle_vcpu(vc) );
- /* csched_cpu_pick() looks in vc->processor's runq, so we need the lock. */
+ /* csched_res_pick() looks in vc->processor's runq, so we need the lock. */
lock = vcpu_schedule_lock_irq(vc);
- vc->processor = csched_cpu_pick(ops, unit);
- unit->res = get_sched_res(vc->processor);
+ unit->res = csched_res_pick(ops, unit);
+ vc->processor = unit->res->master_cpu;
spin_unlock_irq(lock);
@@ -2278,7 +2278,7 @@ static const struct scheduler sched_credit_def = {
.adjust_affinity= csched_aff_cntl,
.adjust_global = csched_sys_cntl,
- .pick_cpu = csched_cpu_pick,
+ .pick_resource = csched_res_pick,
.do_schedule = csched_schedule,
.dump_cpu_state = csched_dump_pcpu,
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 200de63bee..cea4a11087 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -626,9 +626,9 @@ static inline bool has_cap(const struct csched2_vcpu *svc)
* runq, _always_ happens by means of tickling:
* - when a vcpu wakes up, it calls csched2_unit_wake(), which calls
* runq_tickle();
- * - when a migration is initiated in schedule.c, we call csched2_cpu_pick(),
+ * - when a migration is initiated in schedule.c, we call csched2_res_pick(),
* csched2_unit_migrate() (which calls migrate()) and csched2_unit_wake().
- * csched2_cpu_pick() looks for the least loaded runq and return just any
+ * csched2_res_pick() looks for the least loaded runq and return just any
* of its processors. Then, csched2_unit_migrate() just moves the vcpu to
* the chosen runq, and it is again runq_tickle(), called by
* csched2_unit_wake() that actually decides what pcpu to use within the
@@ -677,7 +677,7 @@ void smt_idle_mask_clear(unsigned int cpu, cpumask_t *mask)
}
/*
- * In csched2_cpu_pick(), it may not be possible to actually look at remote
+ * In csched2_res_pick(), it may not be possible to actually look at remote
* runqueues (the trylock-s on their spinlocks can fail!). If that happens,
* we pick, in order of decreasing preference:
* 1) svc's current pcpu, if it is part of svc's soft affinity;
@@ -2202,8 +2202,8 @@ csched2_context_saved(const struct scheduler *ops, struct sched_unit *unit)
}
#define MAX_LOAD (STIME_MAX)
-static int
-csched2_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
+static struct sched_resource *
+csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
struct csched2_private *prv = csched2_priv(ops);
struct vcpu *vc = unit->vcpu_list;
@@ -2215,7 +2215,7 @@ csched2_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
ASSERT(!cpumask_empty(&prv->active_queues));
- SCHED_STAT_CRANK(pick_cpu);
+ SCHED_STAT_CRANK(pick_resource);
/* Locking:
* - Runqueue lock of vc->processor is already locked
@@ -2424,7 +2424,7 @@ csched2_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
(unsigned char *)&d);
}
- return new_cpu;
+ return get_sched_res(new_cpu);
}
/* Working state of the load-balancing algorithm */
@@ -3121,11 +3121,11 @@ csched2_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
ASSERT(!is_idle_vcpu(vc));
ASSERT(list_empty(&svc->runq_elem));
- /* csched2_cpu_pick() expects the pcpu lock to be held */
+ /* csched2_res_pick() expects the pcpu lock to be held */
lock = vcpu_schedule_lock_irq(vc);
- vc->processor = csched2_cpu_pick(ops, unit);
- unit->res = get_sched_res(vc->processor);
+ unit->res = csched2_res_pick(ops, unit);
+ vc->processor = unit->res->master_cpu;
spin_unlock_irq(lock);
@@ -4112,7 +4112,7 @@ static const struct scheduler sched_credit2_def = {
.adjust_affinity= csched2_aff_cntl,
.adjust_global = csched2_sys_cntl,
- .pick_cpu = csched2_cpu_pick,
+ .pick_resource = csched2_res_pick,
.migrate = csched2_unit_migrate,
.do_schedule = csched2_schedule,
.context_saved = csched2_context_saved,
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index c30fe2e443..3bb3a53452 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -261,9 +261,11 @@ static void null_free_domdata(const struct scheduler *ops, void *data)
*
* So this is not part of any hot path.
*/
-static unsigned int pick_cpu(struct null_private *prv, struct vcpu *v)
+static struct sched_resource *
+pick_res(struct null_private *prv, const struct sched_unit *unit)
{
unsigned int bs;
+ struct vcpu *v = unit->vcpu_list;
unsigned int cpu = v->processor, new_cpu;
cpumask_t *cpus = cpupool_domain_cpumask(v->domain);
@@ -327,7 +329,7 @@ static unsigned int pick_cpu(struct null_private *prv, struct vcpu *v)
__trace_var(TRC_SNULL_PICKED_CPU, 1, sizeof(d), &d);
}
- return new_cpu;
+ return get_sched_res(new_cpu);
}
static void vcpu_assign(struct null_private *prv, struct vcpu *v,
@@ -457,8 +459,8 @@ static void null_unit_insert(const struct scheduler *ops,
}
retry:
- cpu = v->processor = pick_cpu(prv, v);
- unit->res = get_sched_res(cpu);
+ unit->res = pick_res(prv, unit);
+ cpu = v->processor = unit->res->master_cpu;
spin_unlock(lock);
@@ -599,7 +601,7 @@ static void null_unit_wake(const struct scheduler *ops,
*/
while ( cpumask_intersects(&prv->cpus_free, cpumask_scratch_cpu(cpu)) )
{
- unsigned int new_cpu = pick_cpu(prv, v);
+ unsigned int new_cpu = pick_res(prv, unit)->master_cpu;
if ( test_and_clear_bit(new_cpu, &prv->cpus_free) )
{
@@ -648,12 +650,11 @@ static void null_unit_sleep(const struct scheduler *ops,
SCHED_STAT_CRANK(vcpu_sleep);
}
-static int null_cpu_pick(const struct scheduler *ops,
- const struct sched_unit *unit)
+static struct sched_resource *
+null_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
- struct vcpu *v = unit->vcpu_list;
- ASSERT(!is_idle_vcpu(v));
- return pick_cpu(null_priv(ops), v);
+ ASSERT(!is_idle_vcpu(unit->vcpu_list));
+ return pick_res(null_priv(ops), unit);
}
static void null_unit_migrate(const struct scheduler *ops,
@@ -985,7 +986,7 @@ static const struct scheduler sched_null_def = {
.wake = null_unit_wake,
.sleep = null_unit_sleep,
- .pick_cpu = null_cpu_pick,
+ .pick_resource = null_res_pick,
.migrate = null_unit_migrate,
.do_schedule = null_schedule,
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index 3ba76f1c4a..f303271399 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -631,12 +631,12 @@ replq_reinsert(const struct scheduler *ops, struct rt_vcpu *svc)
}
/*
- * Pick a valid CPU for the vcpu vc
- * Valid CPU of a vcpu is intesection of vcpu's affinity
- * and available cpus
+ * Pick a valid resource for the vcpu vc
+ * Valid resource of a vcpu is intesection of vcpu's affinity
+ * and available resources
*/
-static int
-rt_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
+static struct sched_resource *
+rt_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
cpumask_t cpus;
@@ -651,7 +651,7 @@ rt_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
: cpumask_cycle(vc->processor, &cpus);
ASSERT( !cpumask_empty(&cpus) && cpumask_test_cpu(cpu, &cpus) );
- return cpu;
+ return get_sched_res(cpu);
}
/*
@@ -892,8 +892,8 @@ rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
BUG_ON( is_idle_vcpu(vc) );
/* This is safe because vc isn't yet being scheduled */
- vc->processor = rt_cpu_pick(ops, unit);
- unit->res = get_sched_res(vc->processor);
+ unit->res = rt_res_pick(ops, unit);
+ vc->processor = unit->res->master_cpu;
lock = vcpu_schedule_lock_irq(vc);
@@ -1562,7 +1562,7 @@ static const struct scheduler sched_rtds_def = {
.adjust = rt_dom_cntl,
- .pick_cpu = rt_cpu_pick,
+ .pick_resource = rt_res_pick,
.do_schedule = rt_schedule,
.sleep = rt_unit_sleep,
.wake = rt_unit_wake,
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 2bf7966476..b7cdc15bd1 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -87,10 +87,10 @@ sched_idle_switch_sched(struct scheduler *new_ops, unsigned int cpu,
return &sched_free_cpu_lock;
}
-static int
-sched_idle_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit)
+static struct sched_resource *
+sched_idle_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
- return unit->res->master_cpu;
+ return unit->res;
}
static void *
@@ -122,7 +122,7 @@ static struct scheduler sched_idle_ops = {
.opt_name = "idle",
.sched_data = NULL,
- .pick_cpu = sched_idle_cpu_pick,
+ .pick_resource = sched_idle_res_pick,
.do_schedule = sched_idle_schedule,
.alloc_vdata = sched_idle_alloc_vdata,
@@ -746,7 +746,8 @@ static void vcpu_migrate_finish(struct vcpu *v)
break;
/* Select a new CPU. */
- new_cpu = sched_pick_cpu(vcpu_scheduler(v), v->sched_unit);
+ new_cpu = sched_pick_resource(vcpu_scheduler(v),
+ v->sched_unit)->master_cpu;
if ( (new_lock == per_cpu(schedule_data, new_cpu).schedule_lock) &&
cpumask_test_cpu(new_cpu, v->domain->cpupool->cpu_valid) )
break;
@@ -839,8 +840,9 @@ void restore_vcpu_affinity(struct domain *d)
/* v->processor might have changed, so reacquire the lock. */
lock = vcpu_schedule_lock_irq(v);
- v->processor = sched_pick_cpu(vcpu_scheduler(v), v->sched_unit);
- v->sched_unit->res = get_sched_res(v->processor);
+ v->sched_unit->res = sched_pick_resource(vcpu_scheduler(v),
+ v->sched_unit);
+ v->processor = v->sched_unit->res->master_cpu;
spin_unlock_irq(lock);
if ( old_cpu != v->processor )
@@ -1853,7 +1855,7 @@ void __init scheduler_init(void)
sched_test_func(init);
sched_test_func(deinit);
- sched_test_func(pick_cpu);
+ sched_test_func(pick_resource);
sched_test_func(alloc_vdata);
sched_test_func(free_vdata);
sched_test_func(switch_sched);
diff --git a/xen/include/xen/perfc_defn.h b/xen/include/xen/perfc_defn.h
index ef6f86b91e..1ad4384080 100644
--- a/xen/include/xen/perfc_defn.h
+++ b/xen/include/xen/perfc_defn.h
@@ -69,7 +69,7 @@ PERFCOUNTER(migrate_on_runq, "csched2: migrate_on_runq")
PERFCOUNTER(migrate_no_runq, "csched2: migrate_no_runq")
PERFCOUNTER(runtime_min_timer, "csched2: runtime_min_timer")
PERFCOUNTER(runtime_max_timer, "csched2: runtime_max_timer")
-PERFCOUNTER(pick_cpu, "csched2: pick_cpu")
+PERFCOUNTER(pick_resource, "csched2: pick_resource")
PERFCOUNTER(need_fallback_cpu, "csched2: need_fallback_cpu")
PERFCOUNTER(migrated, "csched2: migrated")
PERFCOUNTER(migrate_resisted, "csched2: migrate_resisted")
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index b9e2920c66..2d9d77c6d3 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -189,8 +189,8 @@ struct scheduler {
struct task_slice (*do_schedule) (const struct scheduler *, s_time_t,
bool_t tasklet_work_scheduled);
- int (*pick_cpu) (const struct scheduler *,
- const struct sched_unit *);
+ struct sched_resource *(*pick_resource)(const struct scheduler *,
+ const struct sched_unit *);
void (*migrate) (const struct scheduler *,
struct sched_unit *, unsigned int);
int (*adjust) (const struct scheduler *, struct domain *,
@@ -355,10 +355,10 @@ static inline void sched_migrate(const struct scheduler *s,
}
}
-static inline int sched_pick_cpu(const struct scheduler *s,
- const struct sched_unit *unit)
+static inline struct sched_resource *sched_pick_resource(
+ const struct scheduler *s, const struct sched_unit *unit)
{
- return s->pick_cpu(s, unit);
+ return s->pick_resource(s, unit);
}
static inline void sched_adjust_affinity(const struct scheduler *s,
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 06/47] xen/sched: switch schedule_data.curr to point at sched_unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (4 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 05/47] xen/sched: let pick_cpu return a scheduler resource Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource Juergen Gross
` (42 subsequent siblings)
48 siblings, 0 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Robert VanVossen, Dario Faggioli, Julien Grall, Josh Whitehead,
Meng Xu, Jan Beulich
In preparation of core scheduling let the percpu pointer
schedule_data.curr point to a strct sched_unit instead of the related
vcpu. At the same time rename the per-vcpu scheduler specific structs
to per-unit ones.
Signed-off-by: Juergen Gross <jgross@suse.com>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
---
V3:
- remove no longer matching comment (Jan Beulich)
---
xen/common/sched_arinc653.c | 2 +-
xen/common/sched_credit.c | 105 ++++++++++++++-------------
xen/common/sched_credit2.c | 168 ++++++++++++++++++++++----------------------
xen/common/sched_null.c | 46 ++++++------
xen/common/sched_rt.c | 118 +++++++++++++++----------------
xen/common/schedule.c | 8 +--
xen/include/xen/sched-if.h | 2 +-
7 files changed, 222 insertions(+), 227 deletions(-)
diff --git a/xen/common/sched_arinc653.c b/xen/common/sched_arinc653.c
index 9754aaa503..8585d9c4fe 100644
--- a/xen/common/sched_arinc653.c
+++ b/xen/common/sched_arinc653.c
@@ -475,7 +475,7 @@ a653sched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
* If the VCPU being put to sleep is the same one that is currently
* running, raise a softirq to invoke the scheduler to switch domains.
*/
- if ( per_cpu(schedule_data, vc->processor).curr == vc )
+ if ( per_cpu(schedule_data, vc->processor).curr == unit )
cpu_raise_softirq(vc->processor, SCHEDULE_SOFTIRQ);
}
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index b34cc32ce0..b7d44efc8b 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -83,7 +83,7 @@
((struct csched_private *)((_ops)->sched_data))
#define CSCHED_PCPU(_c) \
((struct csched_pcpu *)per_cpu(schedule_data, _c).sched_priv)
-#define CSCHED_VCPU(_vcpu) ((struct csched_vcpu *) (_vcpu)->sched_unit->priv)
+#define CSCHED_UNIT(unit) ((struct csched_unit *) (unit)->priv)
#define CSCHED_DOM(_dom) ((struct csched_dom *) (_dom)->sched_priv)
#define RUNQ(_cpu) (&(CSCHED_PCPU(_cpu)->runq))
@@ -160,7 +160,7 @@ struct csched_pcpu {
/*
* Virtual CPU
*/
-struct csched_vcpu {
+struct csched_unit {
struct list_head runq_elem;
struct list_head active_vcpu_elem;
@@ -233,15 +233,15 @@ static void csched_tick(void *_cpu);
static void csched_acct(void *dummy);
static inline int
-__vcpu_on_runq(struct csched_vcpu *svc)
+__vcpu_on_runq(struct csched_unit *svc)
{
return !list_empty(&svc->runq_elem);
}
-static inline struct csched_vcpu *
+static inline struct csched_unit *
__runq_elem(struct list_head *elem)
{
- return list_entry(elem, struct csched_vcpu, runq_elem);
+ return list_entry(elem, struct csched_unit, runq_elem);
}
/* Is the first element of cpu's runq (if any) cpu's idle vcpu? */
@@ -273,7 +273,7 @@ dec_nr_runnable(unsigned int cpu)
}
static inline void
-__runq_insert(struct csched_vcpu *svc)
+__runq_insert(struct csched_unit *svc)
{
unsigned int cpu = svc->vcpu->processor;
const struct list_head * const runq = RUNQ(cpu);
@@ -283,7 +283,7 @@ __runq_insert(struct csched_vcpu *svc)
list_for_each( iter, runq )
{
- const struct csched_vcpu * const iter_svc = __runq_elem(iter);
+ const struct csched_unit * const iter_svc = __runq_elem(iter);
if ( svc->pri > iter_svc->pri )
break;
}
@@ -304,34 +304,34 @@ __runq_insert(struct csched_vcpu *svc)
}
static inline void
-runq_insert(struct csched_vcpu *svc)
+runq_insert(struct csched_unit *svc)
{
__runq_insert(svc);
inc_nr_runnable(svc->vcpu->processor);
}
static inline void
-__runq_remove(struct csched_vcpu *svc)
+__runq_remove(struct csched_unit *svc)
{
BUG_ON( !__vcpu_on_runq(svc) );
list_del_init(&svc->runq_elem);
}
static inline void
-runq_remove(struct csched_vcpu *svc)
+runq_remove(struct csched_unit *svc)
{
dec_nr_runnable(svc->vcpu->processor);
__runq_remove(svc);
}
-static void burn_credits(struct csched_vcpu *svc, s_time_t now)
+static void burn_credits(struct csched_unit *svc, s_time_t now)
{
s_time_t delta;
uint64_t val;
unsigned int credits;
/* Assert svc is current */
- ASSERT( svc == CSCHED_VCPU(curr_on_cpu(svc->vcpu->processor)) );
+ ASSERT( svc == CSCHED_UNIT(curr_on_cpu(svc->vcpu->processor)) );
if ( (delta = now - svc->start_time) <= 0 )
return;
@@ -349,10 +349,10 @@ boolean_param("tickle_one_idle_cpu", opt_tickle_one_idle);
DEFINE_PER_CPU(unsigned int, last_tickle_cpu);
-static inline void __runq_tickle(struct csched_vcpu *new)
+static inline void __runq_tickle(struct csched_unit *new)
{
unsigned int cpu = new->vcpu->processor;
- struct csched_vcpu * const cur = CSCHED_VCPU(curr_on_cpu(cpu));
+ struct csched_unit * const cur = CSCHED_UNIT(curr_on_cpu(cpu));
struct csched_private *prv = CSCHED_PRIV(per_cpu(scheduler, cpu));
cpumask_t mask, idle_mask, *online;
int balance_step, idlers_empty;
@@ -607,7 +607,7 @@ init_pdata(struct csched_private *prv, struct csched_pcpu *spc, int cpu)
spc->idle_bias = nr_cpu_ids - 1;
/* Start off idling... */
- BUG_ON(!is_idle_vcpu(curr_on_cpu(cpu)));
+ BUG_ON(!is_idle_vcpu(curr_on_cpu(cpu)->vcpu_list));
cpumask_set_cpu(cpu, prv->idlers);
spc->nr_runnable = 0;
}
@@ -630,7 +630,7 @@ csched_switch_sched(struct scheduler *new_ops, unsigned int cpu,
{
struct schedule_data *sd = &per_cpu(schedule_data, cpu);
struct csched_private *prv = CSCHED_PRIV(new_ops);
- struct csched_vcpu *svc = vdata;
+ struct csched_unit *svc = vdata;
ASSERT(svc && is_idle_vcpu(svc->vcpu));
@@ -653,7 +653,7 @@ csched_switch_sched(struct scheduler *new_ops, unsigned int cpu,
static inline void
__csched_vcpu_check(struct vcpu *vc)
{
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
+ struct csched_unit * const svc = CSCHED_UNIT(vc->sched_unit);
struct csched_dom * const sdom = svc->sdom;
BUG_ON( svc->vcpu != vc );
@@ -686,7 +686,7 @@ integer_param("vcpu_migration_delay", vcpu_migration_delay_us);
static inline bool
__csched_vcpu_is_cache_hot(const struct csched_private *prv,
- const struct csched_vcpu *svc)
+ const struct csched_unit *svc)
{
bool hot = prv->vcpu_migr_delay &&
(NOW() - svc->last_sched_time) < prv->vcpu_migr_delay;
@@ -701,7 +701,7 @@ static inline int
__csched_vcpu_is_migrateable(const struct csched_private *prv, struct vcpu *vc,
int dest_cpu, cpumask_t *mask)
{
- const struct csched_vcpu *svc = CSCHED_VCPU(vc);
+ const struct csched_unit *svc = CSCHED_UNIT(vc->sched_unit);
/*
* Don't pick up work that's hot on peer PCPU, or that can't (or
* would prefer not to) run on cpu.
@@ -857,7 +857,7 @@ static struct sched_resource *
csched_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched_vcpu *svc = CSCHED_VCPU(vc);
+ struct csched_unit *svc = CSCHED_UNIT(unit);
/*
* We have been called by vcpu_migrate() (in schedule.c), as part
@@ -871,7 +871,7 @@ csched_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
}
static inline void
-__csched_vcpu_acct_start(struct csched_private *prv, struct csched_vcpu *svc)
+__csched_vcpu_acct_start(struct csched_private *prv, struct csched_unit *svc)
{
struct csched_dom * const sdom = svc->sdom;
unsigned long flags;
@@ -901,7 +901,7 @@ __csched_vcpu_acct_start(struct csched_private *prv, struct csched_vcpu *svc)
static inline void
__csched_vcpu_acct_stop_locked(struct csched_private *prv,
- struct csched_vcpu *svc)
+ struct csched_unit *svc)
{
struct csched_dom * const sdom = svc->sdom;
@@ -926,7 +926,7 @@ __csched_vcpu_acct_stop_locked(struct csched_private *prv,
static void
csched_vcpu_acct(struct csched_private *prv, unsigned int cpu)
{
- struct csched_vcpu * const svc = CSCHED_VCPU(current);
+ struct csched_unit * const svc = CSCHED_UNIT(current->sched_unit);
const struct scheduler *ops = per_cpu(scheduler, cpu);
ASSERT( current->processor == cpu );
@@ -995,10 +995,10 @@ csched_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
void *dd)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched_vcpu *svc;
+ struct csched_unit *svc;
/* Allocate per-VCPU info */
- svc = xzalloc(struct csched_vcpu);
+ svc = xzalloc(struct csched_unit);
if ( svc == NULL )
return NULL;
@@ -1017,7 +1017,7 @@ static void
csched_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched_vcpu *svc = unit->priv;
+ struct csched_unit *svc = unit->priv;
spinlock_t *lock;
BUG_ON( is_idle_vcpu(vc) );
@@ -1043,7 +1043,7 @@ csched_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
static void
csched_free_vdata(const struct scheduler *ops, void *priv)
{
- struct csched_vcpu *svc = priv;
+ struct csched_unit *svc = priv;
BUG_ON( !list_empty(&svc->runq_elem) );
@@ -1054,8 +1054,7 @@ static void
csched_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
{
struct csched_private *prv = CSCHED_PRIV(ops);
- struct vcpu *vc = unit->vcpu_list;
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
+ struct csched_unit * const svc = CSCHED_UNIT(unit);
struct csched_dom * const sdom = svc->sdom;
SCHED_STAT_CRANK(vcpu_remove);
@@ -1082,14 +1081,14 @@ static void
csched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
+ struct csched_unit * const svc = CSCHED_UNIT(unit);
unsigned int cpu = vc->processor;
SCHED_STAT_CRANK(vcpu_sleep);
BUG_ON( is_idle_vcpu(vc) );
- if ( curr_on_cpu(cpu) == vc )
+ if ( curr_on_cpu(cpu) == unit )
{
/*
* We are about to tickle cpu, so we should clear its bit in idlers.
@@ -1107,12 +1106,12 @@ static void
csched_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
+ struct csched_unit * const svc = CSCHED_UNIT(unit);
bool_t migrating;
BUG_ON( is_idle_vcpu(vc) );
- if ( unlikely(curr_on_cpu(vc->processor) == vc) )
+ if ( unlikely(curr_on_cpu(vc->processor) == unit) )
{
SCHED_STAT_CRANK(vcpu_wake_running);
return;
@@ -1168,8 +1167,7 @@ csched_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
static void
csched_unit_yield(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
- struct csched_vcpu * const svc = CSCHED_VCPU(vc);
+ struct csched_unit * const svc = CSCHED_UNIT(unit);
/* Let the scheduler know that this vcpu is trying to yield */
set_bit(CSCHED_FLAG_VCPU_YIELD, &svc->flags);
@@ -1224,8 +1222,7 @@ static void
csched_aff_cntl(const struct scheduler *ops, struct sched_unit *unit,
const cpumask_t *hard, const cpumask_t *soft)
{
- struct vcpu *v = unit->vcpu_list;
- struct csched_vcpu *svc = CSCHED_VCPU(v);
+ struct csched_unit *svc = CSCHED_UNIT(unit);
if ( !hard )
return;
@@ -1328,7 +1325,7 @@ csched_runq_sort(struct csched_private *prv, unsigned int cpu)
{
struct csched_pcpu * const spc = CSCHED_PCPU(cpu);
struct list_head *runq, *elem, *next, *last_under;
- struct csched_vcpu *svc_elem;
+ struct csched_unit *svc_elem;
spinlock_t *lock;
unsigned long flags;
int sort_epoch;
@@ -1374,7 +1371,7 @@ csched_acct(void* dummy)
unsigned long flags;
struct list_head *iter_vcpu, *next_vcpu;
struct list_head *iter_sdom, *next_sdom;
- struct csched_vcpu *svc;
+ struct csched_unit *svc;
struct csched_dom *sdom;
uint32_t credit_total;
uint32_t weight_total;
@@ -1497,7 +1494,7 @@ csched_acct(void* dummy)
list_for_each_safe( iter_vcpu, next_vcpu, &sdom->active_vcpu )
{
- svc = list_entry(iter_vcpu, struct csched_vcpu, active_vcpu_elem);
+ svc = list_entry(iter_vcpu, struct csched_unit, active_vcpu_elem);
BUG_ON( sdom != svc->sdom );
/* Increment credit */
@@ -1601,12 +1598,12 @@ csched_tick(void *_cpu)
set_timer(&spc->ticker, NOW() + MICROSECS(prv->tick_period_us) );
}
-static struct csched_vcpu *
+static struct csched_unit *
csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
{
const struct csched_private * const prv = CSCHED_PRIV(per_cpu(scheduler, cpu));
const struct csched_pcpu * const peer_pcpu = CSCHED_PCPU(peer_cpu);
- struct csched_vcpu *speer;
+ struct csched_unit *speer;
struct list_head *iter;
struct vcpu *vc;
@@ -1616,7 +1613,7 @@ csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
* Don't steal from an idle CPU's runq because it's about to
* pick up work from it itself.
*/
- if ( unlikely(is_idle_vcpu(curr_on_cpu(peer_cpu))) )
+ if ( unlikely(is_idle_vcpu(curr_on_cpu(peer_cpu)->vcpu_list)) )
goto out;
list_for_each( iter, &peer_pcpu->runq )
@@ -1678,12 +1675,12 @@ csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
return NULL;
}
-static struct csched_vcpu *
+static struct csched_unit *
csched_load_balance(struct csched_private *prv, int cpu,
- struct csched_vcpu *snext, bool_t *stolen)
+ struct csched_unit *snext, bool_t *stolen)
{
struct cpupool *c = per_cpu(cpupool, cpu);
- struct csched_vcpu *speer;
+ struct csched_unit *speer;
cpumask_t workers;
cpumask_t *online;
int peer_cpu, first_cpu, peer_node, bstep;
@@ -1832,9 +1829,9 @@ csched_schedule(
{
const int cpu = smp_processor_id();
struct list_head * const runq = RUNQ(cpu);
- struct csched_vcpu * const scurr = CSCHED_VCPU(current);
+ struct csched_unit * const scurr = CSCHED_UNIT(current->sched_unit);
struct csched_private *prv = CSCHED_PRIV(ops);
- struct csched_vcpu *snext;
+ struct csched_unit *snext;
struct task_slice ret;
s_time_t runtime, tslice;
@@ -1951,7 +1948,7 @@ csched_schedule(
if ( tasklet_work_scheduled )
{
TRACE_0D(TRC_CSCHED_SCHED_TASKLET);
- snext = CSCHED_VCPU(idle_vcpu[cpu]);
+ snext = CSCHED_UNIT(idle_vcpu[cpu]->sched_unit);
snext->pri = CSCHED_PRI_TS_BOOST;
}
@@ -2003,7 +2000,7 @@ out:
}
static void
-csched_dump_vcpu(struct csched_vcpu *svc)
+csched_dump_vcpu(struct csched_unit *svc)
{
struct csched_dom * const sdom = svc->sdom;
@@ -2039,7 +2036,7 @@ csched_dump_pcpu(const struct scheduler *ops, int cpu)
struct list_head *runq, *iter;
struct csched_private *prv = CSCHED_PRIV(ops);
struct csched_pcpu *spc;
- struct csched_vcpu *svc;
+ struct csched_unit *svc;
spinlock_t *lock;
unsigned long flags;
int loop;
@@ -2063,7 +2060,7 @@ csched_dump_pcpu(const struct scheduler *ops, int cpu)
CPUMASK_PR(per_cpu(cpu_core_mask, cpu)));
/* current VCPU (nothing to say if that's the idle vcpu). */
- svc = CSCHED_VCPU(curr_on_cpu(cpu));
+ svc = CSCHED_UNIT(curr_on_cpu(cpu));
if ( svc && !is_idle_vcpu(svc->vcpu) )
{
printk("\trun: ");
@@ -2132,10 +2129,10 @@ csched_dump(const struct scheduler *ops)
list_for_each( iter_svc, &sdom->active_vcpu )
{
- struct csched_vcpu *svc;
+ struct csched_unit *svc;
spinlock_t *lock;
- svc = list_entry(iter_svc, struct csched_vcpu, active_vcpu_elem);
+ svc = list_entry(iter_svc, struct csched_unit, active_vcpu_elem);
lock = vcpu_schedule_lock(svc->vcpu);
printk("\t%3d: ", ++loop);
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index cea4a11087..4982f1ef36 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -176,7 +176,7 @@
* load balancing;
* + serializes runqueue operations (removing and inserting vcpus);
* + protects runqueue-wide data in csched2_runqueue_data;
- * + protects vcpu parameters in csched2_vcpu for the vcpu in the
+ * + protects vcpu parameters in csched2_unit for the vcpu in the
* runqueue.
*
* - Private scheduler lock
@@ -512,7 +512,7 @@ struct csched2_pcpu {
/*
* Virtual CPU
*/
-struct csched2_vcpu {
+struct csched2_unit {
struct csched2_dom *sdom; /* Up-pointer to domain */
struct vcpu *vcpu; /* Up-pointer, to vcpu */
struct csched2_runqueue_data *rqd; /* Up-pointer to the runqueue */
@@ -571,9 +571,9 @@ static inline struct csched2_pcpu *csched2_pcpu(unsigned int cpu)
return per_cpu(schedule_data, cpu).sched_priv;
}
-static inline struct csched2_vcpu *csched2_vcpu(const struct vcpu *v)
+static inline struct csched2_unit *csched2_unit(const struct sched_unit *unit)
{
- return v->sched_unit->priv;
+ return unit->priv;
}
static inline struct csched2_dom *csched2_dom(const struct domain *d)
@@ -595,7 +595,7 @@ static inline struct csched2_runqueue_data *c2rqd(const struct scheduler *ops,
}
/* Does the domain of this vCPU have a cap? */
-static inline bool has_cap(const struct csched2_vcpu *svc)
+static inline bool has_cap(const struct csched2_unit *svc)
{
return svc->budget != STIME_MAX;
}
@@ -689,7 +689,7 @@ void smt_idle_mask_clear(unsigned int cpu, cpumask_t *mask)
* Of course, 1, 2 and 3 makes sense only if svc has a soft affinity. Also
* note that at least 5 is guaranteed to _always_ return at least one pcpu.
*/
-static int get_fallback_cpu(struct csched2_vcpu *svc)
+static int get_fallback_cpu(struct csched2_unit *svc)
{
struct vcpu *v = svc->vcpu;
unsigned int bs;
@@ -774,7 +774,7 @@ static int get_fallback_cpu(struct csched2_vcpu *svc)
* FIXME: Do pre-calculated division?
*/
static void t2c_update(struct csched2_runqueue_data *rqd, s_time_t time,
- struct csched2_vcpu *svc)
+ struct csched2_unit *svc)
{
uint64_t val = time * rqd->max_weight + svc->residual;
@@ -782,7 +782,7 @@ static void t2c_update(struct csched2_runqueue_data *rqd, s_time_t time,
svc->credit -= val;
}
-static s_time_t c2t(struct csched2_runqueue_data *rqd, s_time_t credit, struct csched2_vcpu *svc)
+static s_time_t c2t(struct csched2_runqueue_data *rqd, s_time_t credit, struct csched2_unit *svc)
{
return credit * svc->weight / rqd->max_weight;
}
@@ -791,14 +791,14 @@ static s_time_t c2t(struct csched2_runqueue_data *rqd, s_time_t credit, struct c
* Runqueue related code.
*/
-static inline int vcpu_on_runq(struct csched2_vcpu *svc)
+static inline int vcpu_on_runq(struct csched2_unit *svc)
{
return !list_empty(&svc->runq_elem);
}
-static inline struct csched2_vcpu * runq_elem(struct list_head *elem)
+static inline struct csched2_unit * runq_elem(struct list_head *elem)
{
- return list_entry(elem, struct csched2_vcpu, runq_elem);
+ return list_entry(elem, struct csched2_unit, runq_elem);
}
static void activate_runqueue(struct csched2_private *prv, int rqi)
@@ -916,7 +916,7 @@ static void update_max_weight(struct csched2_runqueue_data *rqd, int new_weight,
list_for_each( iter, &rqd->svc )
{
- struct csched2_vcpu * svc = list_entry(iter, struct csched2_vcpu, rqd_elem);
+ struct csched2_unit * svc = list_entry(iter, struct csched2_unit, rqd_elem);
if ( svc->weight > max_weight )
max_weight = svc->weight;
@@ -941,7 +941,7 @@ static void update_max_weight(struct csched2_runqueue_data *rqd, int new_weight,
/* Add and remove from runqueue assignment (not active run queue) */
static void
-_runq_assign(struct csched2_vcpu *svc, struct csched2_runqueue_data *rqd)
+_runq_assign(struct csched2_unit *svc, struct csched2_runqueue_data *rqd)
{
svc->rqd = rqd;
@@ -971,7 +971,7 @@ _runq_assign(struct csched2_vcpu *svc, struct csched2_runqueue_data *rqd)
static void
runq_assign(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched2_vcpu *svc = vc->sched_unit->priv;
+ struct csched2_unit *svc = vc->sched_unit->priv;
ASSERT(svc->rqd == NULL);
@@ -979,7 +979,7 @@ runq_assign(const struct scheduler *ops, struct vcpu *vc)
}
static void
-_runq_deassign(struct csched2_vcpu *svc)
+_runq_deassign(struct csched2_unit *svc)
{
struct csched2_runqueue_data *rqd = svc->rqd;
@@ -998,7 +998,7 @@ _runq_deassign(struct csched2_vcpu *svc)
static void
runq_deassign(const struct scheduler *ops, struct vcpu *vc)
{
- struct csched2_vcpu *svc = vc->sched_unit->priv;
+ struct csched2_unit *svc = vc->sched_unit->priv;
ASSERT(svc->rqd == c2rqd(ops, vc->processor));
@@ -1200,7 +1200,7 @@ update_runq_load(const struct scheduler *ops,
static void
update_svc_load(const struct scheduler *ops,
- struct csched2_vcpu *svc, int change, s_time_t now)
+ struct csched2_unit *svc, int change, s_time_t now)
{
struct csched2_private *prv = csched2_priv(ops);
s_time_t delta, vcpu_load;
@@ -1260,7 +1260,7 @@ update_svc_load(const struct scheduler *ops,
static void
update_load(const struct scheduler *ops,
struct csched2_runqueue_data *rqd,
- struct csched2_vcpu *svc, int change, s_time_t now)
+ struct csched2_unit *svc, int change, s_time_t now)
{
trace_var(TRC_CSCHED2_UPDATE_LOAD, 1, 0, NULL);
@@ -1270,7 +1270,7 @@ update_load(const struct scheduler *ops,
}
static void
-runq_insert(const struct scheduler *ops, struct csched2_vcpu *svc)
+runq_insert(const struct scheduler *ops, struct csched2_unit *svc)
{
struct list_head *iter;
unsigned int cpu = svc->vcpu->processor;
@@ -1289,7 +1289,7 @@ runq_insert(const struct scheduler *ops, struct csched2_vcpu *svc)
list_for_each( iter, runq )
{
- struct csched2_vcpu * iter_svc = runq_elem(iter);
+ struct csched2_unit * iter_svc = runq_elem(iter);
if ( svc->credit > iter_svc->credit )
break;
@@ -1313,13 +1313,13 @@ runq_insert(const struct scheduler *ops, struct csched2_vcpu *svc)
}
}
-static inline void runq_remove(struct csched2_vcpu *svc)
+static inline void runq_remove(struct csched2_unit *svc)
{
ASSERT(vcpu_on_runq(svc));
list_del_init(&svc->runq_elem);
}
-void burn_credits(struct csched2_runqueue_data *rqd, struct csched2_vcpu *, s_time_t);
+void burn_credits(struct csched2_runqueue_data *rqd, struct csched2_unit *, s_time_t);
static inline void
tickle_cpu(unsigned int cpu, struct csched2_runqueue_data *rqd)
@@ -1335,7 +1335,7 @@ tickle_cpu(unsigned int cpu, struct csched2_runqueue_data *rqd)
* whether or not it already run for more than the ratelimit, to which we
* apply some tolerance).
*/
-static inline bool is_preemptable(const struct csched2_vcpu *svc,
+static inline bool is_preemptable(const struct csched2_unit *svc,
s_time_t now, s_time_t ratelimit)
{
if ( ratelimit <= CSCHED2_RATELIMIT_TICKLE_TOLERANCE )
@@ -1361,10 +1361,10 @@ static inline bool is_preemptable(const struct csched2_vcpu *svc,
* Within the same class, the highest difference of credit.
*/
static s_time_t tickle_score(const struct scheduler *ops, s_time_t now,
- struct csched2_vcpu *new, unsigned int cpu)
+ struct csched2_unit *new, unsigned int cpu)
{
struct csched2_runqueue_data *rqd = c2rqd(ops, cpu);
- struct csched2_vcpu * cur = csched2_vcpu(curr_on_cpu(cpu));
+ struct csched2_unit * cur = csched2_unit(curr_on_cpu(cpu));
struct csched2_private *prv = csched2_priv(ops);
s_time_t score;
@@ -1433,7 +1433,7 @@ static s_time_t tickle_score(const struct scheduler *ops, s_time_t now,
* pick up some work, so it would be wrong to consider it idle.
*/
static void
-runq_tickle(const struct scheduler *ops, struct csched2_vcpu *new, s_time_t now)
+runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
{
int i, ipid = -1;
s_time_t max = 0;
@@ -1588,7 +1588,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_vcpu *new, s_time_t now)
return;
}
- ASSERT(!is_idle_vcpu(curr_on_cpu(ipid)));
+ ASSERT(!is_idle_vcpu(curr_on_cpu(ipid)->vcpu_list));
SCHED_STAT_CRANK(tickled_busy_cpu);
tickle:
BUG_ON(ipid == -1);
@@ -1615,7 +1615,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_vcpu *new, s_time_t now)
* Credit-related code
*/
static void reset_credit(const struct scheduler *ops, int cpu, s_time_t now,
- struct csched2_vcpu *snext)
+ struct csched2_unit *snext)
{
struct csched2_runqueue_data *rqd = c2rqd(ops, cpu);
struct list_head *iter;
@@ -1645,10 +1645,10 @@ static void reset_credit(const struct scheduler *ops, int cpu, s_time_t now,
list_for_each( iter, &rqd->svc )
{
unsigned int svc_cpu;
- struct csched2_vcpu * svc;
+ struct csched2_unit * svc;
int start_credit;
- svc = list_entry(iter, struct csched2_vcpu, rqd_elem);
+ svc = list_entry(iter, struct csched2_unit, rqd_elem);
svc_cpu = svc->vcpu->processor;
ASSERT(!is_idle_vcpu(svc->vcpu));
@@ -1658,7 +1658,7 @@ static void reset_credit(const struct scheduler *ops, int cpu, s_time_t now,
* If svc is running, it is our responsibility to make sure, here,
* that the credit it has spent so far get accounted.
*/
- if ( svc->vcpu == curr_on_cpu(svc_cpu) )
+ if ( svc->vcpu == curr_on_cpu(svc_cpu)->vcpu_list )
{
burn_credits(rqd, svc, now);
/*
@@ -1710,11 +1710,11 @@ static void reset_credit(const struct scheduler *ops, int cpu, s_time_t now,
}
void burn_credits(struct csched2_runqueue_data *rqd,
- struct csched2_vcpu *svc, s_time_t now)
+ struct csched2_unit *svc, s_time_t now)
{
s_time_t delta;
- ASSERT(svc == csched2_vcpu(curr_on_cpu(svc->vcpu->processor)));
+ ASSERT(svc == csched2_unit(curr_on_cpu(svc->vcpu->processor)));
if ( unlikely(is_idle_vcpu(svc->vcpu)) )
{
@@ -1764,7 +1764,7 @@ void burn_credits(struct csched2_runqueue_data *rqd,
* Budget-related code.
*/
-static void park_vcpu(struct csched2_vcpu *svc)
+static void park_vcpu(struct csched2_unit *svc)
{
struct vcpu *v = svc->vcpu;
@@ -1793,7 +1793,7 @@ static void park_vcpu(struct csched2_vcpu *svc)
list_add(&svc->parked_elem, &svc->sdom->parked_vcpus);
}
-static bool vcpu_grab_budget(struct csched2_vcpu *svc)
+static bool vcpu_grab_budget(struct csched2_unit *svc)
{
struct csched2_dom *sdom = svc->sdom;
unsigned int cpu = svc->vcpu->processor;
@@ -1840,7 +1840,7 @@ static bool vcpu_grab_budget(struct csched2_vcpu *svc)
}
static void
-vcpu_return_budget(struct csched2_vcpu *svc, struct list_head *parked)
+vcpu_return_budget(struct csched2_unit *svc, struct list_head *parked)
{
struct csched2_dom *sdom = svc->sdom;
unsigned int cpu = svc->vcpu->processor;
@@ -1883,7 +1883,7 @@ vcpu_return_budget(struct csched2_vcpu *svc, struct list_head *parked)
static void
unpark_parked_vcpus(const struct scheduler *ops, struct list_head *vcpus)
{
- struct csched2_vcpu *svc, *tmp;
+ struct csched2_unit *svc, *tmp;
spinlock_t *lock;
list_for_each_entry_safe(svc, tmp, vcpus, parked_elem)
@@ -2005,7 +2005,7 @@ static void replenish_domain_budget(void* data)
static inline void
csched2_vcpu_check(struct vcpu *vc)
{
- struct csched2_vcpu * const svc = csched2_vcpu(vc);
+ struct csched2_unit * const svc = csched2_unit(vc->sched_unit);
struct csched2_dom * const sdom = svc->sdom;
BUG_ON( svc->vcpu != vc );
@@ -2031,10 +2031,10 @@ csched2_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
void *dd)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched2_vcpu *svc;
+ struct csched2_unit *svc;
/* Allocate per-VCPU info */
- svc = xzalloc(struct csched2_vcpu);
+ svc = xzalloc(struct csched2_unit);
if ( svc == NULL )
return NULL;
@@ -2075,12 +2075,12 @@ static void
csched2_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched2_vcpu * const svc = csched2_vcpu(vc);
+ struct csched2_unit * const svc = csched2_unit(unit);
ASSERT(!is_idle_vcpu(vc));
SCHED_STAT_CRANK(vcpu_sleep);
- if ( curr_on_cpu(vc->processor) == vc )
+ if ( curr_on_cpu(vc->processor) == unit )
{
tickle_cpu(vc->processor, svc->rqd);
}
@@ -2098,7 +2098,7 @@ static void
csched2_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched2_vcpu * const svc = csched2_vcpu(vc);
+ struct csched2_unit * const svc = csched2_unit(unit);
unsigned int cpu = vc->processor;
s_time_t now;
@@ -2106,7 +2106,7 @@ csched2_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
ASSERT(!is_idle_vcpu(vc));
- if ( unlikely(curr_on_cpu(cpu) == vc) )
+ if ( unlikely(curr_on_cpu(cpu) == unit) )
{
SCHED_STAT_CRANK(vcpu_wake_running);
goto out;
@@ -2153,8 +2153,7 @@ out:
static void
csched2_unit_yield(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *v = unit->vcpu_list;
- struct csched2_vcpu * const svc = csched2_vcpu(v);
+ struct csched2_unit * const svc = csched2_unit(unit);
__set_bit(__CSFLAG_vcpu_yield, &svc->flags);
}
@@ -2163,7 +2162,7 @@ static void
csched2_context_saved(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched2_vcpu * const svc = csched2_vcpu(vc);
+ struct csched2_unit * const svc = csched2_unit(unit);
spinlock_t *lock = vcpu_schedule_lock_irq(vc);
s_time_t now = NOW();
LIST_HEAD(were_parked);
@@ -2209,7 +2208,7 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
struct vcpu *vc = unit->vcpu_list;
int i, min_rqi = -1, min_s_rqi = -1;
unsigned int new_cpu, cpu = vc->processor;
- struct csched2_vcpu *svc = csched2_vcpu(vc);
+ struct csched2_unit *svc = csched2_unit(unit);
s_time_t min_avgload = MAX_LOAD, min_s_avgload = MAX_LOAD;
bool has_soft;
@@ -2431,15 +2430,15 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
typedef struct {
/* NB: Modified by consider() */
s_time_t load_delta;
- struct csched2_vcpu * best_push_svc, *best_pull_svc;
+ struct csched2_unit * best_push_svc, *best_pull_svc;
/* NB: Read by consider() */
struct csched2_runqueue_data *lrqd;
struct csched2_runqueue_data *orqd;
} balance_state_t;
static void consider(balance_state_t *st,
- struct csched2_vcpu *push_svc,
- struct csched2_vcpu *pull_svc)
+ struct csched2_unit *push_svc,
+ struct csched2_unit *pull_svc)
{
s_time_t l_load, o_load, delta;
@@ -2472,8 +2471,8 @@ static void consider(balance_state_t *st,
static void migrate(const struct scheduler *ops,
- struct csched2_vcpu *svc,
- struct csched2_runqueue_data *trqd,
+ struct csched2_unit *svc,
+ struct csched2_runqueue_data *trqd,
s_time_t now)
{
int cpu = svc->vcpu->processor;
@@ -2542,7 +2541,7 @@ static void migrate(const struct scheduler *ops,
* - svc is not already flagged to migrate,
* - if svc is allowed to run on at least one of the pcpus of rqd.
*/
-static bool vcpu_is_migrateable(struct csched2_vcpu *svc,
+static bool vcpu_is_migrateable(struct csched2_unit *svc,
struct csched2_runqueue_data *rqd)
{
struct vcpu *v = svc->vcpu;
@@ -2692,7 +2691,7 @@ retry:
/* Reuse load delta (as we're trying to minimize it) */
list_for_each( push_iter, &st.lrqd->svc )
{
- struct csched2_vcpu * push_svc = list_entry(push_iter, struct csched2_vcpu, rqd_elem);
+ struct csched2_unit * push_svc = list_entry(push_iter, struct csched2_unit, rqd_elem);
update_svc_load(ops, push_svc, 0, now);
@@ -2701,7 +2700,7 @@ retry:
list_for_each( pull_iter, &st.orqd->svc )
{
- struct csched2_vcpu * pull_svc = list_entry(pull_iter, struct csched2_vcpu, rqd_elem);
+ struct csched2_unit * pull_svc = list_entry(pull_iter, struct csched2_unit, rqd_elem);
if ( !inner_load_updated )
update_svc_load(ops, pull_svc, 0, now);
@@ -2720,7 +2719,7 @@ retry:
list_for_each( pull_iter, &st.orqd->svc )
{
- struct csched2_vcpu * pull_svc = list_entry(pull_iter, struct csched2_vcpu, rqd_elem);
+ struct csched2_unit * pull_svc = list_entry(pull_iter, struct csched2_unit, rqd_elem);
if ( !vcpu_is_migrateable(pull_svc, st.lrqd) )
continue;
@@ -2747,7 +2746,7 @@ csched2_unit_migrate(
{
struct vcpu *vc = unit->vcpu_list;
struct domain *d = vc->domain;
- struct csched2_vcpu * const svc = csched2_vcpu(vc);
+ struct csched2_unit * const svc = csched2_unit(unit);
struct csched2_runqueue_data *trqd;
s_time_t now = NOW();
@@ -2848,7 +2847,7 @@ csched2_dom_cntl(
/* Update weights for vcpus, and max_weight for runqueues on which they reside */
for_each_vcpu ( d, v )
{
- struct csched2_vcpu *svc = csched2_vcpu(v);
+ struct csched2_unit *svc = csched2_unit(v->sched_unit);
spinlock_t *lock = vcpu_schedule_lock(svc->vcpu);
ASSERT(svc->rqd == c2rqd(ops, svc->vcpu->processor));
@@ -2862,7 +2861,7 @@ csched2_dom_cntl(
/* Cap */
if ( op->u.credit2.cap != 0 )
{
- struct csched2_vcpu *svc;
+ struct csched2_unit *svc;
spinlock_t *lock;
/* Cap is only valid if it's below 100 * nr_of_vCPUS */
@@ -2886,7 +2885,7 @@ csched2_dom_cntl(
*/
for_each_vcpu ( d, v )
{
- svc = csched2_vcpu(v);
+ svc = csched2_unit(v->sched_unit);
lock = vcpu_schedule_lock(svc->vcpu);
/*
* Too small quotas would in theory cause a lot of overhead,
@@ -2929,14 +2928,14 @@ csched2_dom_cntl(
*/
for_each_vcpu ( d, v )
{
- svc = csched2_vcpu(v);
+ svc = csched2_unit(v->sched_unit);
lock = vcpu_schedule_lock(svc->vcpu);
if ( v->is_running )
{
unsigned int cpu = v->processor;
struct csched2_runqueue_data *rqd = c2rqd(ops, cpu);
- ASSERT(curr_on_cpu(cpu) == v);
+ ASSERT(curr_on_cpu(cpu)->vcpu_list == v);
/*
* We are triggering a reschedule on the vCPU's
@@ -2976,7 +2975,7 @@ csched2_dom_cntl(
/* Disable budget accounting for all the vCPUs. */
for_each_vcpu ( d, v )
{
- struct csched2_vcpu *svc = csched2_vcpu(v);
+ struct csched2_unit *svc = csched2_unit(v->sched_unit);
spinlock_t *lock = vcpu_schedule_lock(svc->vcpu);
svc->budget = STIME_MAX;
@@ -3013,8 +3012,7 @@ static void
csched2_aff_cntl(const struct scheduler *ops, struct sched_unit *unit,
const cpumask_t *hard, const cpumask_t *soft)
{
- struct vcpu *v = unit->vcpu_list;
- struct csched2_vcpu *svc = csched2_vcpu(v);
+ struct csched2_unit *svc = csched2_unit(unit);
if ( !hard )
return;
@@ -3114,7 +3112,7 @@ static void
csched2_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched2_vcpu *svc = unit->priv;
+ struct csched2_unit *svc = unit->priv;
struct csched2_dom * const sdom = svc->sdom;
spinlock_t *lock;
@@ -3146,7 +3144,7 @@ csched2_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
static void
csched2_free_vdata(const struct scheduler *ops, void *priv)
{
- struct csched2_vcpu *svc = priv;
+ struct csched2_unit *svc = priv;
xfree(svc);
}
@@ -3155,7 +3153,7 @@ static void
csched2_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct csched2_vcpu * const svc = csched2_vcpu(vc);
+ struct csched2_unit * const svc = csched2_unit(unit);
spinlock_t *lock;
ASSERT(!is_idle_vcpu(vc));
@@ -3176,7 +3174,7 @@ csched2_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
/* How long should we let this vcpu run for? */
static s_time_t
csched2_runtime(const struct scheduler *ops, int cpu,
- struct csched2_vcpu *snext, s_time_t now)
+ struct csched2_unit *snext, s_time_t now)
{
s_time_t time, min_time;
int rt_credit; /* Proposed runtime measured in credits */
@@ -3221,7 +3219,7 @@ csched2_runtime(const struct scheduler *ops, int cpu,
*/
if ( ! list_empty(runq) )
{
- struct csched2_vcpu *swait = runq_elem(runq->next);
+ struct csched2_unit *swait = runq_elem(runq->next);
if ( ! is_idle_vcpu(swait->vcpu)
&& swait->credit > 0 )
@@ -3272,14 +3270,14 @@ csched2_runtime(const struct scheduler *ops, int cpu,
/*
* Find a candidate.
*/
-static struct csched2_vcpu *
+static struct csched2_unit *
runq_candidate(struct csched2_runqueue_data *rqd,
- struct csched2_vcpu *scurr,
+ struct csched2_unit *scurr,
int cpu, s_time_t now,
unsigned int *skipped)
{
struct list_head *iter, *temp;
- struct csched2_vcpu *snext = NULL;
+ struct csched2_unit *snext = NULL;
struct csched2_private *prv = csched2_priv(per_cpu(scheduler, cpu));
bool yield = false, soft_aff_preempt = false;
@@ -3360,12 +3358,12 @@ runq_candidate(struct csched2_runqueue_data *rqd,
if ( vcpu_runnable(scurr->vcpu) && !soft_aff_preempt )
snext = scurr;
else
- snext = csched2_vcpu(idle_vcpu[cpu]);
+ snext = csched2_unit(idle_vcpu[cpu]->sched_unit);
check_runq:
list_for_each_safe( iter, temp, &rqd->runq )
{
- struct csched2_vcpu * svc = list_entry(iter, struct csched2_vcpu, runq_elem);
+ struct csched2_unit * svc = list_entry(iter, struct csched2_unit, runq_elem);
if ( unlikely(tb_init_done) )
{
@@ -3464,8 +3462,8 @@ csched2_schedule(
{
const int cpu = smp_processor_id();
struct csched2_runqueue_data *rqd;
- struct csched2_vcpu * const scurr = csched2_vcpu(current);
- struct csched2_vcpu *snext = NULL;
+ struct csched2_unit * const scurr = csched2_unit(current->sched_unit);
+ struct csched2_unit *snext = NULL;
unsigned int skipped_vcpus = 0;
struct task_slice ret;
bool tickled;
@@ -3541,7 +3539,7 @@ csched2_schedule(
{
__clear_bit(__CSFLAG_vcpu_yield, &scurr->flags);
trace_var(TRC_CSCHED2_SCHED_TASKLET, 1, 0, NULL);
- snext = csched2_vcpu(idle_vcpu[cpu]);
+ snext = csched2_unit(idle_vcpu[cpu]->sched_unit);
}
else
snext = runq_candidate(rqd, scurr, cpu, now, &skipped_vcpus);
@@ -3644,7 +3642,7 @@ csched2_schedule(
}
static void
-csched2_dump_vcpu(struct csched2_private *prv, struct csched2_vcpu *svc)
+csched2_dump_vcpu(struct csched2_private *prv, struct csched2_unit *svc)
{
printk("[%i.%i] flags=%x cpu=%i",
svc->vcpu->domain->domain_id,
@@ -3668,7 +3666,7 @@ static inline void
dump_pcpu(const struct scheduler *ops, int cpu)
{
struct csched2_private *prv = csched2_priv(ops);
- struct csched2_vcpu *svc;
+ struct csched2_unit *svc;
printk("CPU[%02d] runq=%d, sibling=%*pb, core=%*pb\n",
cpu, c2r(cpu),
@@ -3676,7 +3674,7 @@ dump_pcpu(const struct scheduler *ops, int cpu)
CPUMASK_PR(per_cpu(cpu_core_mask, cpu)));
/* current VCPU (nothing to say if that's the idle vcpu) */
- svc = csched2_vcpu(curr_on_cpu(cpu));
+ svc = csched2_unit(curr_on_cpu(cpu));
if ( svc && !is_idle_vcpu(svc->vcpu) )
{
printk("\trun: ");
@@ -3749,7 +3747,7 @@ csched2_dump(const struct scheduler *ops)
for_each_vcpu( sdom->dom, v )
{
- struct csched2_vcpu * const svc = csched2_vcpu(v);
+ struct csched2_unit * const svc = csched2_unit(v->sched_unit);
spinlock_t *lock;
lock = vcpu_schedule_lock(svc->vcpu);
@@ -3778,7 +3776,7 @@ csched2_dump(const struct scheduler *ops)
printk("RUNQ:\n");
list_for_each( iter, runq )
{
- struct csched2_vcpu *svc = runq_elem(iter);
+ struct csched2_unit *svc = runq_elem(iter);
if ( svc )
{
@@ -3882,7 +3880,7 @@ csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu,
void *pdata, void *vdata)
{
struct csched2_private *prv = csched2_priv(new_ops);
- struct csched2_vcpu *svc = vdata;
+ struct csched2_unit *svc = vdata;
unsigned rqi;
ASSERT(pdata && svc && is_idle_vcpu(svc->vcpu));
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index 3bb3a53452..d7d0e77cb5 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -93,7 +93,7 @@ DEFINE_PER_CPU(struct null_pcpu, npc);
/*
* Virtual CPU
*/
-struct null_vcpu {
+struct null_unit {
struct list_head waitq_elem;
struct vcpu *vcpu;
};
@@ -114,9 +114,9 @@ static inline struct null_private *null_priv(const struct scheduler *ops)
return ops->sched_data;
}
-static inline struct null_vcpu *null_vcpu(const struct vcpu *v)
+static inline struct null_unit *null_unit(const struct sched_unit *unit)
{
- return v->sched_unit->priv;
+ return unit->priv;
}
static inline bool vcpu_check_affinity(struct vcpu *v, unsigned int cpu,
@@ -189,9 +189,9 @@ static void *null_alloc_vdata(const struct scheduler *ops,
struct sched_unit *unit, void *dd)
{
struct vcpu *v = unit->vcpu_list;
- struct null_vcpu *nvc;
+ struct null_unit *nvc;
- nvc = xzalloc(struct null_vcpu);
+ nvc = xzalloc(struct null_unit);
if ( nvc == NULL )
return NULL;
@@ -205,7 +205,7 @@ static void *null_alloc_vdata(const struct scheduler *ops,
static void null_free_vdata(const struct scheduler *ops, void *priv)
{
- struct null_vcpu *nvc = priv;
+ struct null_unit *nvc = priv;
xfree(nvc);
}
@@ -362,9 +362,9 @@ static bool vcpu_deassign(struct null_private *prv, struct vcpu *v)
{
unsigned int bs;
unsigned int cpu = v->processor;
- struct null_vcpu *wvc;
+ struct null_unit *wvc;
- ASSERT(list_empty(&null_vcpu(v)->waitq_elem));
+ ASSERT(list_empty(&null_unit(v->sched_unit)->waitq_elem));
ASSERT(per_cpu(npc, v->processor).vcpu == v);
ASSERT(!cpumask_test_cpu(v->processor, &prv->cpus_free));
@@ -421,7 +421,7 @@ static spinlock_t *null_switch_sched(struct scheduler *new_ops,
{
struct schedule_data *sd = &per_cpu(schedule_data, cpu);
struct null_private *prv = null_priv(new_ops);
- struct null_vcpu *nvc = vdata;
+ struct null_unit *nvc = vdata;
ASSERT(nvc && is_idle_vcpu(nvc->vcpu));
@@ -444,7 +444,7 @@ static void null_unit_insert(const struct scheduler *ops,
{
struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
- struct null_vcpu *nvc = null_vcpu(v);
+ struct null_unit *nvc = null_unit(unit);
unsigned int cpu;
spinlock_t *lock;
@@ -508,7 +508,7 @@ static void null_unit_remove(const struct scheduler *ops,
{
struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
- struct null_vcpu *nvc = null_vcpu(v);
+ struct null_unit *nvc = null_unit(unit);
spinlock_t *lock;
ASSERT(!is_idle_vcpu(v));
@@ -546,12 +546,12 @@ static void null_unit_wake(const struct scheduler *ops,
{
struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
- struct null_vcpu *nvc = null_vcpu(v);
+ struct null_unit *nvc = null_unit(unit);
unsigned int cpu = v->processor;
ASSERT(!is_idle_vcpu(v));
- if ( unlikely(curr_on_cpu(cpu) == v) )
+ if ( unlikely(curr_on_cpu(cpu) == unit) )
{
SCHED_STAT_CRANK(vcpu_wake_running);
return;
@@ -631,7 +631,7 @@ static void null_unit_sleep(const struct scheduler *ops,
*/
if ( unlikely(!is_vcpu_online(v)) )
{
- struct null_vcpu *nvc = null_vcpu(v);
+ struct null_unit *nvc = null_unit(unit);
if ( unlikely(!list_empty(&nvc->waitq_elem)) )
{
@@ -644,7 +644,7 @@ static void null_unit_sleep(const struct scheduler *ops,
}
/* If v is not assigned to a pCPU, or is not running, no need to bother */
- if ( likely(!tickled && curr_on_cpu(cpu) == v) )
+ if ( likely(!tickled && curr_on_cpu(cpu) == unit) )
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
SCHED_STAT_CRANK(vcpu_sleep);
@@ -662,7 +662,7 @@ static void null_unit_migrate(const struct scheduler *ops,
{
struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
- struct null_vcpu *nvc = null_vcpu(v);
+ struct null_unit *nvc = null_unit(unit);
ASSERT(!is_idle_vcpu(v));
@@ -758,7 +758,7 @@ static void null_unit_migrate(const struct scheduler *ops,
#ifndef NDEBUG
static inline void null_vcpu_check(struct vcpu *v)
{
- struct null_vcpu * const nvc = null_vcpu(v);
+ struct null_unit * const nvc = null_unit(v->sched_unit);
struct null_dom * const ndom = v->domain->sched_priv;
BUG_ON(nvc->vcpu != v);
@@ -788,7 +788,7 @@ static struct task_slice null_schedule(const struct scheduler *ops,
unsigned int bs;
const unsigned int cpu = smp_processor_id();
struct null_private *prv = null_priv(ops);
- struct null_vcpu *wvc;
+ struct null_unit *wvc;
struct task_slice ret;
SCHED_STAT_CRANK(schedule);
@@ -874,7 +874,7 @@ static struct task_slice null_schedule(const struct scheduler *ops,
return ret;
}
-static inline void dump_vcpu(struct null_private *prv, struct null_vcpu *nvc)
+static inline void dump_vcpu(struct null_private *prv, struct null_unit *nvc)
{
printk("[%i.%i] pcpu=%d", nvc->vcpu->domain->domain_id,
nvc->vcpu->vcpu_id, list_empty(&nvc->waitq_elem) ?
@@ -884,7 +884,7 @@ static inline void dump_vcpu(struct null_private *prv, struct null_vcpu *nvc)
static void null_dump_pcpu(const struct scheduler *ops, int cpu)
{
struct null_private *prv = null_priv(ops);
- struct null_vcpu *nvc;
+ struct null_unit *nvc;
spinlock_t *lock;
unsigned long flags;
@@ -898,7 +898,7 @@ static void null_dump_pcpu(const struct scheduler *ops, int cpu)
printk("\n");
/* current VCPU (nothing to say if that's the idle vcpu) */
- nvc = null_vcpu(curr_on_cpu(cpu));
+ nvc = null_unit(curr_on_cpu(cpu));
if ( nvc && !is_idle_vcpu(nvc->vcpu) )
{
printk("\trun: ");
@@ -932,7 +932,7 @@ static void null_dump(const struct scheduler *ops)
printk("\tDomain: %d\n", ndom->dom->domain_id);
for_each_vcpu( ndom->dom, v )
{
- struct null_vcpu * const nvc = null_vcpu(v);
+ struct null_unit * const nvc = null_unit(v->sched_unit);
spinlock_t *lock;
lock = vcpu_schedule_lock(nvc->vcpu);
@@ -950,7 +950,7 @@ static void null_dump(const struct scheduler *ops)
spin_lock(&prv->waitq_lock);
list_for_each( iter, &prv->waitq )
{
- struct null_vcpu *nvc = list_entry(iter, struct null_vcpu, waitq_elem);
+ struct null_unit *nvc = list_entry(iter, struct null_unit, waitq_elem);
if ( loop++ != 0 )
printk(", ");
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index f303271399..115e4da24d 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -195,7 +195,7 @@ struct rt_private {
/*
* Virtual CPU
*/
-struct rt_vcpu {
+struct rt_unit {
struct list_head q_elem; /* on the runq/depletedq list */
struct list_head replq_elem; /* on the replenishment events list */
@@ -233,9 +233,9 @@ static inline struct rt_private *rt_priv(const struct scheduler *ops)
return ops->sched_data;
}
-static inline struct rt_vcpu *rt_vcpu(const struct vcpu *vcpu)
+static inline struct rt_unit *rt_unit(const struct sched_unit *unit)
{
- return vcpu->sched_unit->priv;
+ return unit->priv;
}
static inline struct list_head *rt_runq(const struct scheduler *ops)
@@ -253,7 +253,7 @@ static inline struct list_head *rt_replq(const struct scheduler *ops)
return &rt_priv(ops)->replq;
}
-static inline bool has_extratime(const struct rt_vcpu *svc)
+static inline bool has_extratime(const struct rt_unit *svc)
{
return svc->flags & RTDS_extratime;
}
@@ -263,25 +263,25 @@ static inline bool has_extratime(const struct rt_vcpu *svc)
* and the replenishment events queue.
*/
static int
-vcpu_on_q(const struct rt_vcpu *svc)
+vcpu_on_q(const struct rt_unit *svc)
{
return !list_empty(&svc->q_elem);
}
-static struct rt_vcpu *
+static struct rt_unit *
q_elem(struct list_head *elem)
{
- return list_entry(elem, struct rt_vcpu, q_elem);
+ return list_entry(elem, struct rt_unit, q_elem);
}
-static struct rt_vcpu *
+static struct rt_unit *
replq_elem(struct list_head *elem)
{
- return list_entry(elem, struct rt_vcpu, replq_elem);
+ return list_entry(elem, struct rt_unit, replq_elem);
}
static int
-vcpu_on_replq(const struct rt_vcpu *svc)
+vcpu_on_replq(const struct rt_unit *svc)
{
return !list_empty(&svc->replq_elem);
}
@@ -291,7 +291,7 @@ vcpu_on_replq(const struct rt_vcpu *svc)
* Otherwise, return value < 0
*/
static s_time_t
-compare_vcpu_priority(const struct rt_vcpu *v1, const struct rt_vcpu *v2)
+compare_vcpu_priority(const struct rt_unit *v1, const struct rt_unit *v2)
{
int prio = v2->priority_level - v1->priority_level;
@@ -305,7 +305,7 @@ compare_vcpu_priority(const struct rt_vcpu *v1, const struct rt_vcpu *v2)
* Debug related code, dump vcpu/cpu information
*/
static void
-rt_dump_vcpu(const struct scheduler *ops, const struct rt_vcpu *svc)
+rt_dump_vcpu(const struct scheduler *ops, const struct rt_unit *svc)
{
cpumask_t *cpupool_mask, *mask;
@@ -351,13 +351,13 @@ static void
rt_dump_pcpu(const struct scheduler *ops, int cpu)
{
struct rt_private *prv = rt_priv(ops);
- struct rt_vcpu *svc;
+ struct rt_unit *svc;
unsigned long flags;
spin_lock_irqsave(&prv->lock, flags);
printk("CPU[%02d]\n", cpu);
/* current VCPU (nothing to say if that's the idle vcpu). */
- svc = rt_vcpu(curr_on_cpu(cpu));
+ svc = rt_unit(curr_on_cpu(cpu));
if ( svc && !is_idle_vcpu(svc->vcpu) )
{
rt_dump_vcpu(ops, svc);
@@ -370,7 +370,7 @@ rt_dump(const struct scheduler *ops)
{
struct list_head *runq, *depletedq, *replq, *iter;
struct rt_private *prv = rt_priv(ops);
- struct rt_vcpu *svc;
+ struct rt_unit *svc;
struct rt_dom *sdom;
unsigned long flags;
@@ -414,7 +414,7 @@ rt_dump(const struct scheduler *ops)
for_each_vcpu ( sdom->dom, v )
{
- svc = rt_vcpu(v);
+ svc = rt_unit(v->sched_unit);
rt_dump_vcpu(ops, svc);
}
}
@@ -428,7 +428,7 @@ rt_dump(const struct scheduler *ops)
* it needs to be updated to the deadline of the current period
*/
static void
-rt_update_deadline(s_time_t now, struct rt_vcpu *svc)
+rt_update_deadline(s_time_t now, struct rt_unit *svc)
{
ASSERT(now >= svc->cur_deadline);
ASSERT(svc->period != 0);
@@ -499,8 +499,8 @@ deadline_queue_remove(struct list_head *queue, struct list_head *elem)
}
static inline bool
-deadline_queue_insert(struct rt_vcpu * (*qelem)(struct list_head *),
- struct rt_vcpu *svc, struct list_head *elem,
+deadline_queue_insert(struct rt_unit * (*qelem)(struct list_head *),
+ struct rt_unit *svc, struct list_head *elem,
struct list_head *queue)
{
struct list_head *iter;
@@ -508,7 +508,7 @@ deadline_queue_insert(struct rt_vcpu * (*qelem)(struct list_head *),
list_for_each ( iter, queue )
{
- struct rt_vcpu * iter_svc = (*qelem)(iter);
+ struct rt_unit * iter_svc = (*qelem)(iter);
if ( compare_vcpu_priority(svc, iter_svc) > 0 )
break;
pos++;
@@ -522,14 +522,14 @@ deadline_queue_insert(struct rt_vcpu * (*qelem)(struct list_head *),
deadline_queue_insert(&replq_elem, ##__VA_ARGS__)
static inline void
-q_remove(struct rt_vcpu *svc)
+q_remove(struct rt_unit *svc)
{
ASSERT( vcpu_on_q(svc) );
list_del_init(&svc->q_elem);
}
static inline void
-replq_remove(const struct scheduler *ops, struct rt_vcpu *svc)
+replq_remove(const struct scheduler *ops, struct rt_unit *svc)
{
struct rt_private *prv = rt_priv(ops);
struct list_head *replq = rt_replq(ops);
@@ -546,7 +546,7 @@ replq_remove(const struct scheduler *ops, struct rt_vcpu *svc)
*/
if ( !list_empty(replq) )
{
- struct rt_vcpu *svc_next = replq_elem(replq->next);
+ struct rt_unit *svc_next = replq_elem(replq->next);
set_timer(&prv->repl_timer, svc_next->cur_deadline);
}
else
@@ -560,7 +560,7 @@ replq_remove(const struct scheduler *ops, struct rt_vcpu *svc)
* Insert svc without budget in DepletedQ unsorted;
*/
static void
-runq_insert(const struct scheduler *ops, struct rt_vcpu *svc)
+runq_insert(const struct scheduler *ops, struct rt_unit *svc)
{
struct rt_private *prv = rt_priv(ops);
struct list_head *runq = rt_runq(ops);
@@ -578,7 +578,7 @@ runq_insert(const struct scheduler *ops, struct rt_vcpu *svc)
}
static void
-replq_insert(const struct scheduler *ops, struct rt_vcpu *svc)
+replq_insert(const struct scheduler *ops, struct rt_unit *svc)
{
struct list_head *replq = rt_replq(ops);
struct rt_private *prv = rt_priv(ops);
@@ -600,10 +600,10 @@ replq_insert(const struct scheduler *ops, struct rt_vcpu *svc)
* changed.
*/
static void
-replq_reinsert(const struct scheduler *ops, struct rt_vcpu *svc)
+replq_reinsert(const struct scheduler *ops, struct rt_unit *svc)
{
struct list_head *replq = rt_replq(ops);
- struct rt_vcpu *rearm_svc = svc;
+ struct rt_unit *rearm_svc = svc;
bool_t rearm = 0;
ASSERT( vcpu_on_replq(svc) );
@@ -734,7 +734,7 @@ rt_switch_sched(struct scheduler *new_ops, unsigned int cpu,
void *pdata, void *vdata)
{
struct rt_private *prv = rt_priv(new_ops);
- struct rt_vcpu *svc = vdata;
+ struct rt_unit *svc = vdata;
ASSERT(!pdata && svc && is_idle_vcpu(svc->vcpu));
@@ -841,10 +841,10 @@ static void *
rt_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit, void *dd)
{
struct vcpu *vc = unit->vcpu_list;
- struct rt_vcpu *svc;
+ struct rt_unit *svc;
/* Allocate per-VCPU info */
- svc = xzalloc(struct rt_vcpu);
+ svc = xzalloc(struct rt_unit);
if ( svc == NULL )
return NULL;
@@ -869,7 +869,7 @@ rt_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit, void *dd)
static void
rt_free_vdata(const struct scheduler *ops, void *priv)
{
- struct rt_vcpu *svc = priv;
+ struct rt_unit *svc = priv;
xfree(svc);
}
@@ -885,7 +885,7 @@ static void
rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct rt_vcpu *svc = rt_vcpu(vc);
+ struct rt_unit *svc = rt_unit(unit);
s_time_t now;
spinlock_t *lock;
@@ -914,13 +914,13 @@ rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
}
/*
- * Remove rt_vcpu svc from the old scheduler in source cpupool.
+ * Remove rt_unit svc from the old scheduler in source cpupool.
*/
static void
rt_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct rt_vcpu * const svc = rt_vcpu(vc);
+ struct rt_unit * const svc = rt_unit(unit);
struct rt_dom * const sdom = svc->sdom;
spinlock_t *lock;
@@ -942,7 +942,7 @@ rt_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
* Burn budget in nanosecond granularity
*/
static void
-burn_budget(const struct scheduler *ops, struct rt_vcpu *svc, s_time_t now)
+burn_budget(const struct scheduler *ops, struct rt_unit *svc, s_time_t now)
{
s_time_t delta;
@@ -1006,13 +1006,13 @@ burn_budget(const struct scheduler *ops, struct rt_vcpu *svc, s_time_t now)
* RunQ is sorted. Pick first one within cpumask. If no one, return NULL
* lock is grabbed before calling this function
*/
-static struct rt_vcpu *
+static struct rt_unit *
runq_pick(const struct scheduler *ops, const cpumask_t *mask)
{
struct list_head *runq = rt_runq(ops);
struct list_head *iter;
- struct rt_vcpu *svc = NULL;
- struct rt_vcpu *iter_svc = NULL;
+ struct rt_unit *svc = NULL;
+ struct rt_unit *iter_svc = NULL;
cpumask_t cpu_common;
cpumask_t *online;
@@ -1063,8 +1063,8 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
{
const int cpu = smp_processor_id();
struct rt_private *prv = rt_priv(ops);
- struct rt_vcpu *const scurr = rt_vcpu(current);
- struct rt_vcpu *snext = NULL;
+ struct rt_unit *const scurr = rt_unit(current->sched_unit);
+ struct rt_unit *snext = NULL;
struct task_slice ret = { .migrated = 0 };
/* TRACE */
@@ -1090,13 +1090,13 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
if ( tasklet_work_scheduled )
{
trace_var(TRC_RTDS_SCHED_TASKLET, 1, 0, NULL);
- snext = rt_vcpu(idle_vcpu[cpu]);
+ snext = rt_unit(idle_vcpu[cpu]->sched_unit);
}
else
{
snext = runq_pick(ops, cpumask_of(cpu));
if ( snext == NULL )
- snext = rt_vcpu(idle_vcpu[cpu]);
+ snext = rt_unit(idle_vcpu[cpu]->sched_unit);
/* if scurr has higher priority and budget, still pick scurr */
if ( !is_idle_vcpu(current) &&
@@ -1142,12 +1142,12 @@ static void
rt_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct rt_vcpu * const svc = rt_vcpu(vc);
+ struct rt_unit * const svc = rt_unit(unit);
BUG_ON( is_idle_vcpu(vc) );
SCHED_STAT_CRANK(vcpu_sleep);
- if ( curr_on_cpu(vc->processor) == vc )
+ if ( curr_on_cpu(vc->processor) == unit )
cpu_raise_softirq(vc->processor, SCHEDULE_SOFTIRQ);
else if ( vcpu_on_q(svc) )
{
@@ -1177,11 +1177,11 @@ rt_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
* lock is grabbed before calling this function
*/
static void
-runq_tickle(const struct scheduler *ops, struct rt_vcpu *new)
+runq_tickle(const struct scheduler *ops, struct rt_unit *new)
{
struct rt_private *prv = rt_priv(ops);
- struct rt_vcpu *latest_deadline_vcpu = NULL; /* lowest priority */
- struct rt_vcpu *iter_svc;
+ struct rt_unit *latest_deadline_vcpu = NULL; /* lowest priority */
+ struct rt_unit *iter_svc;
struct vcpu *iter_vc;
int cpu = 0, cpu_to_tickle = 0;
cpumask_t not_tickled;
@@ -1202,14 +1202,14 @@ runq_tickle(const struct scheduler *ops, struct rt_vcpu *new)
cpu = cpumask_test_or_cycle(new->vcpu->processor, ¬_tickled);
while ( cpu!= nr_cpu_ids )
{
- iter_vc = curr_on_cpu(cpu);
+ iter_vc = curr_on_cpu(cpu)->vcpu_list;
if ( is_idle_vcpu(iter_vc) )
{
SCHED_STAT_CRANK(tickled_idle_cpu);
cpu_to_tickle = cpu;
goto out;
}
- iter_svc = rt_vcpu(iter_vc);
+ iter_svc = rt_unit(iter_vc->sched_unit);
if ( latest_deadline_vcpu == NULL ||
compare_vcpu_priority(iter_svc, latest_deadline_vcpu) < 0 )
latest_deadline_vcpu = iter_svc;
@@ -1258,13 +1258,13 @@ static void
rt_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct rt_vcpu * const svc = rt_vcpu(vc);
+ struct rt_unit * const svc = rt_unit(unit);
s_time_t now;
bool_t missed;
BUG_ON( is_idle_vcpu(vc) );
- if ( unlikely(curr_on_cpu(vc->processor) == vc) )
+ if ( unlikely(curr_on_cpu(vc->processor) == unit) )
{
SCHED_STAT_CRANK(vcpu_wake_running);
return;
@@ -1329,7 +1329,7 @@ static void
rt_context_saved(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
- struct rt_vcpu *svc = rt_vcpu(vc);
+ struct rt_unit *svc = rt_unit(unit);
spinlock_t *lock = vcpu_schedule_lock_irq(vc);
__clear_bit(__RTDS_scheduled, &svc->flags);
@@ -1360,7 +1360,7 @@ rt_dom_cntl(
struct xen_domctl_scheduler_op *op)
{
struct rt_private *prv = rt_priv(ops);
- struct rt_vcpu *svc;
+ struct rt_unit *svc;
struct vcpu *v;
unsigned long flags;
int rc = 0;
@@ -1384,7 +1384,7 @@ rt_dom_cntl(
spin_lock_irqsave(&prv->lock, flags);
for_each_vcpu ( d, v )
{
- svc = rt_vcpu(v);
+ svc = rt_unit(v->sched_unit);
svc->period = MICROSECS(op->u.rtds.period); /* transfer to nanosec */
svc->budget = MICROSECS(op->u.rtds.budget);
}
@@ -1410,7 +1410,7 @@ rt_dom_cntl(
if ( op->cmd == XEN_DOMCTL_SCHEDOP_getvcpuinfo )
{
spin_lock_irqsave(&prv->lock, flags);
- svc = rt_vcpu(d->vcpu[local_sched.vcpuid]);
+ svc = rt_unit(d->vcpu[local_sched.vcpuid]->sched_unit);
local_sched.u.rtds.budget = svc->budget / MICROSECS(1);
local_sched.u.rtds.period = svc->period / MICROSECS(1);
if ( has_extratime(svc) )
@@ -1438,7 +1438,7 @@ rt_dom_cntl(
}
spin_lock_irqsave(&prv->lock, flags);
- svc = rt_vcpu(d->vcpu[local_sched.vcpuid]);
+ svc = rt_unit(d->vcpu[local_sched.vcpuid]->sched_unit);
svc->period = period;
svc->budget = budget;
if ( local_sched.u.rtds.flags & XEN_DOMCTL_SCHEDRT_extra )
@@ -1471,7 +1471,7 @@ static void repl_timer_handler(void *data){
struct list_head *replq = rt_replq(ops);
struct list_head *runq = rt_runq(ops);
struct list_head *iter, *tmp;
- struct rt_vcpu *svc;
+ struct rt_unit *svc;
LIST_HEAD(tmp_replq);
spin_lock_irq(&prv->lock);
@@ -1513,10 +1513,10 @@ static void repl_timer_handler(void *data){
{
svc = replq_elem(iter);
- if ( curr_on_cpu(svc->vcpu->processor) == svc->vcpu &&
+ if ( curr_on_cpu(svc->vcpu->processor) == svc->vcpu->sched_unit &&
!list_empty(runq) )
{
- struct rt_vcpu *next_on_runq = q_elem(runq->next);
+ struct rt_unit *next_on_runq = q_elem(runq->next);
if ( compare_vcpu_priority(svc, next_on_runq) < 0 )
runq_tickle(ops, next_on_runq);
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index b7cdc15bd1..865c50b378 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -393,7 +393,7 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
/* Idle VCPUs are scheduled immediately, so don't put them in runqueue. */
if ( is_idle_domain(d) )
{
- per_cpu(schedule_data, v->processor).curr = v;
+ per_cpu(schedule_data, v->processor).curr = unit;
v->is_running = 1;
}
else
@@ -1606,7 +1606,7 @@ static void schedule(void)
next = next_slice.task;
- sd->curr = next;
+ sd->curr = next->sched_unit;
if ( next_slice.time >= 0 ) /* -ve means no limit */
set_timer(&sd->s_timer, now + next_slice.time);
@@ -1748,7 +1748,7 @@ static int cpu_schedule_up(unsigned int cpu)
* allocated.
*/
- sd->curr = idle_vcpu[cpu];
+ sd->curr = idle_vcpu[cpu]->sched_unit;
sd->sched_priv = NULL;
@@ -1916,7 +1916,7 @@ void __init scheduler_init(void)
idle_domain->max_vcpus = nr_cpu_ids;
if ( vcpu_create(idle_domain, 0, 0) == NULL )
BUG();
- this_cpu(schedule_data).curr = idle_vcpu[0];
+ this_cpu(schedule_data).curr = idle_vcpu[0]->sched_unit;
}
/*
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 2d9d77c6d3..6aa8d125c8 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -36,7 +36,7 @@ extern int sched_ratelimit_us;
struct schedule_data {
spinlock_t *schedule_lock,
_lock;
- struct vcpu *curr; /* current task */
+ struct sched_unit *curr;
void *sched_priv;
struct timer s_timer; /* scheduling timer */
atomic_t urgent_count; /* how many urgent vcpus */
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (5 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 06/47] xen/sched: switch schedule_data.curr to point at sched_unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-19 15:27 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 08/47] xen/sched: switch vcpu_schedule_lock to unit_schedule_lock Juergen Gross
` (41 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Robert VanVossen, Dario Faggioli, Julien Grall, Josh Whitehead,
Meng Xu, Jan Beulich, Roger Pau Monné
This prepares support of larger scheduling granularities, e.g. core
scheduling.
While at it move sched_has_urgent_vcpu() from include/asm-x86/cpuidle.h
into sched.h removing the need for including sched-if.h in cpuidle.h.
For that purpose remobe urgent_count from the scheduler private data
and make it a plain percpu variable.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V1:
- move sched_has_urgent_vcpu()
V2:
- make sched_has_urgent_vcpu() return bool (Jan Beulich)
V3:
- split out removing sched-if.h include in some C files (Jan Beulich)
- make urgent_count a plain percpu variable (Jan Beulich)
---
xen/common/sched_arinc653.c | 4 ++--
xen/common/sched_credit.c | 10 ++++----
xen/common/sched_credit2.c | 21 +++++++++--------
xen/common/sched_null.c | 4 ++--
xen/common/sched_rt.c | 9 +++----
xen/common/schedule.c | 55 ++++++++++++++++++++++---------------------
xen/include/asm-x86/cpuidle.h | 11 ---------
xen/include/xen/sched-if.h | 23 ++++++++----------
xen/include/xen/sched.h | 11 +++++++++
9 files changed, 74 insertions(+), 74 deletions(-)
diff --git a/xen/common/sched_arinc653.c b/xen/common/sched_arinc653.c
index 8585d9c4fe..98cdd7f894 100644
--- a/xen/common/sched_arinc653.c
+++ b/xen/common/sched_arinc653.c
@@ -475,7 +475,7 @@ a653sched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
* If the VCPU being put to sleep is the same one that is currently
* running, raise a softirq to invoke the scheduler to switch domains.
*/
- if ( per_cpu(schedule_data, vc->processor).curr == unit )
+ if ( get_sched_res(vc->processor)->curr == unit )
cpu_raise_softirq(vc->processor, SCHEDULE_SOFTIRQ);
}
@@ -643,7 +643,7 @@ static spinlock_t *
a653_switch_sched(struct scheduler *new_ops, unsigned int cpu,
void *pdata, void *vdata)
{
- struct schedule_data *sd = &per_cpu(schedule_data, cpu);
+ struct sched_resource *sd = get_sched_res(cpu);
arinc653_vcpu_t *svc = vdata;
ASSERT(!pdata && svc && is_idle_vcpu(svc->vc));
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index b7d44efc8b..ee42de6bce 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -82,7 +82,7 @@
#define CSCHED_PRIV(_ops) \
((struct csched_private *)((_ops)->sched_data))
#define CSCHED_PCPU(_c) \
- ((struct csched_pcpu *)per_cpu(schedule_data, _c).sched_priv)
+ ((struct csched_pcpu *)get_sched_res(_c)->sched_priv)
#define CSCHED_UNIT(unit) ((struct csched_unit *) (unit)->priv)
#define CSCHED_DOM(_dom) ((struct csched_dom *) (_dom)->sched_priv)
#define RUNQ(_cpu) (&(CSCHED_PCPU(_cpu)->runq))
@@ -250,7 +250,7 @@ static inline bool_t is_runq_idle(unsigned int cpu)
/*
* We're peeking at cpu's runq, we must hold the proper lock.
*/
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
return list_empty(RUNQ(cpu)) ||
is_idle_vcpu(__runq_elem(RUNQ(cpu)->next)->vcpu);
@@ -259,7 +259,7 @@ static inline bool_t is_runq_idle(unsigned int cpu)
static inline void
inc_nr_runnable(unsigned int cpu)
{
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
CSCHED_PCPU(cpu)->nr_runnable++;
}
@@ -267,7 +267,7 @@ inc_nr_runnable(unsigned int cpu)
static inline void
dec_nr_runnable(unsigned int cpu)
{
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
ASSERT(CSCHED_PCPU(cpu)->nr_runnable >= 1);
CSCHED_PCPU(cpu)->nr_runnable--;
}
@@ -628,7 +628,7 @@ static spinlock_t *
csched_switch_sched(struct scheduler *new_ops, unsigned int cpu,
void *pdata, void *vdata)
{
- struct schedule_data *sd = &per_cpu(schedule_data, cpu);
+ struct sched_resource *sd = get_sched_res(cpu);
struct csched_private *prv = CSCHED_PRIV(new_ops);
struct csched_unit *svc = vdata;
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 4982f1ef36..849f3a916e 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -568,7 +568,7 @@ static inline struct csched2_private *csched2_priv(const struct scheduler *ops)
static inline struct csched2_pcpu *csched2_pcpu(unsigned int cpu)
{
- return per_cpu(schedule_data, cpu).sched_priv;
+ return get_sched_res(cpu)->sched_priv;
}
static inline struct csched2_unit *csched2_unit(const struct sched_unit *unit)
@@ -1277,7 +1277,7 @@ runq_insert(const struct scheduler *ops, struct csched2_unit *svc)
struct list_head * runq = &c2rqd(ops, cpu)->runq;
int pos = 0;
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
ASSERT(!vcpu_on_runq(svc));
ASSERT(c2r(cpu) == c2r(svc->vcpu->processor));
@@ -1798,7 +1798,7 @@ static bool vcpu_grab_budget(struct csched2_unit *svc)
struct csched2_dom *sdom = svc->sdom;
unsigned int cpu = svc->vcpu->processor;
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
if ( svc->budget > 0 )
return true;
@@ -1845,7 +1845,7 @@ vcpu_return_budget(struct csched2_unit *svc, struct list_head *parked)
struct csched2_dom *sdom = svc->sdom;
unsigned int cpu = svc->vcpu->processor;
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
ASSERT(list_empty(parked));
/* budget_lock nests inside runqueue lock. */
@@ -2102,7 +2102,7 @@ csched2_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
unsigned int cpu = vc->processor;
s_time_t now;
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
ASSERT(!is_idle_vcpu(vc));
@@ -2230,7 +2230,7 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
* just grab the prv lock. Instead, we'll have to trylock, and
* do something else reasonable if we fail.
*/
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
if ( !read_trylock(&prv->lock) )
{
@@ -2570,7 +2570,7 @@ static void balance_load(const struct scheduler *ops, int cpu, s_time_t now)
* on either side may be empty).
*/
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
st.lrqd = c2rqd(ops, cpu);
update_runq_load(ops, st.lrqd, 0, now);
@@ -3476,7 +3476,7 @@ csched2_schedule(
rqd = c2rqd(ops, cpu);
BUG_ON(!cpumask_test_cpu(cpu, &rqd->active));
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
BUG_ON(!is_idle_vcpu(scurr->vcpu) && scurr->rqd != rqd);
@@ -3867,7 +3867,7 @@ csched2_init_pdata(const struct scheduler *ops, void *pdata, int cpu)
rqi = init_pdata(prv, pdata, cpu);
/* Move the scheduler lock to the new runq lock. */
- per_cpu(schedule_data, cpu).schedule_lock = &prv->rqd[rqi].lock;
+ get_sched_res(cpu)->schedule_lock = &prv->rqd[rqi].lock;
/* _Not_ pcpu_schedule_unlock(): schedule_lock may have changed! */
spin_unlock(old_lock);
@@ -3881,6 +3881,7 @@ csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu,
{
struct csched2_private *prv = csched2_priv(new_ops);
struct csched2_unit *svc = vdata;
+ struct sched_resource *sd = get_sched_res(cpu);
unsigned rqi;
ASSERT(pdata && svc && is_idle_vcpu(svc->vcpu));
@@ -3906,7 +3907,7 @@ csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu,
* this scheduler, and so it's safe to have taken it /before/ our
* private global lock.
*/
- ASSERT(per_cpu(schedule_data, cpu).schedule_lock != &prv->rqd[rqi].lock);
+ ASSERT(sd->schedule_lock != &prv->rqd[rqi].lock);
write_unlock(&prv->lock);
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index d7d0e77cb5..e7ba55c650 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -269,7 +269,7 @@ pick_res(struct null_private *prv, const struct sched_unit *unit)
unsigned int cpu = v->processor, new_cpu;
cpumask_t *cpus = cpupool_domain_cpumask(v->domain);
- ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
for_each_affinity_balance_step( bs )
{
@@ -419,7 +419,7 @@ static spinlock_t *null_switch_sched(struct scheduler *new_ops,
unsigned int cpu,
void *pdata, void *vdata)
{
- struct schedule_data *sd = &per_cpu(schedule_data, cpu);
+ struct sched_resource *sd = get_sched_res(cpu);
struct null_private *prv = null_priv(new_ops);
struct null_unit *nvc = vdata;
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index 115e4da24d..f31c7dc02c 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -75,7 +75,7 @@
/*
* Locking:
* A global system lock is used to protect the RunQ and DepletedQ.
- * The global lock is referenced by schedule_data.schedule_lock
+ * The global lock is referenced by sched_res->schedule_lock
* from all physical cpus.
*
* The lock is already grabbed when calling wake/sleep/schedule/ functions
@@ -176,7 +176,7 @@ static void repl_timer_handler(void *data);
/*
* System-wide private data, include global RunQueue/DepletedQ
- * Global lock is referenced by schedule_data.schedule_lock from all
+ * Global lock is referenced by sched_res->schedule_lock from all
* physical cpus. It can be grabbed via vcpu_schedule_lock_irq()
*/
struct rt_private {
@@ -722,7 +722,7 @@ rt_init_pdata(const struct scheduler *ops, void *pdata, int cpu)
}
/* Move the scheduler lock to our global runqueue lock. */
- per_cpu(schedule_data, cpu).schedule_lock = &prv->lock;
+ get_sched_res(cpu)->schedule_lock = &prv->lock;
/* _Not_ pcpu_schedule_unlock(): per_cpu().schedule_lock changed! */
spin_unlock_irqrestore(old_lock, flags);
@@ -735,6 +735,7 @@ rt_switch_sched(struct scheduler *new_ops, unsigned int cpu,
{
struct rt_private *prv = rt_priv(new_ops);
struct rt_unit *svc = vdata;
+ struct sched_resource *sd = get_sched_res(cpu);
ASSERT(!pdata && svc && is_idle_vcpu(svc->vcpu));
@@ -744,7 +745,7 @@ rt_switch_sched(struct scheduler *new_ops, unsigned int cpu,
* another scheduler, but that is how things need to be, for
* preventing races.
*/
- ASSERT(per_cpu(schedule_data, cpu).schedule_lock != &prv->lock);
+ ASSERT(sd->schedule_lock != &prv->lock);
/*
* If we are the absolute first cpu being switched toward this
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 865c50b378..42bca8df54 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -65,13 +65,15 @@ static void vcpu_singleshot_timer_fn(void *data);
static void poll_timer_fn(void *data);
/* This is global for now so that private implementations can reach it */
-DEFINE_PER_CPU(struct schedule_data, schedule_data);
DEFINE_PER_CPU(struct scheduler *, scheduler);
DEFINE_PER_CPU_READ_MOSTLY(struct sched_resource *, sched_res);
/* Scratch space for cpumasks. */
DEFINE_PER_CPU(cpumask_t, cpumask_scratch);
+/* How many urgent vcpus. */
+DEFINE_PER_CPU(atomic_t, sched_urgent_count);
+
extern const struct scheduler *__start_schedulers_array[], *__end_schedulers_array[];
#define NUM_SCHEDULERS (__end_schedulers_array - __start_schedulers_array)
#define schedulers __start_schedulers_array
@@ -213,7 +215,7 @@ static inline void vcpu_urgent_count_update(struct vcpu *v)
!test_bit(v->vcpu_id, v->domain->poll_mask) )
{
v->is_urgent = 0;
- atomic_dec(&per_cpu(schedule_data,v->processor).urgent_count);
+ atomic_dec(&per_cpu(sched_urgent_count, v->processor));
}
}
else
@@ -222,7 +224,7 @@ static inline void vcpu_urgent_count_update(struct vcpu *v)
unlikely(test_bit(v->vcpu_id, v->domain->poll_mask)) )
{
v->is_urgent = 1;
- atomic_inc(&per_cpu(schedule_data,v->processor).urgent_count);
+ atomic_inc(&per_cpu(sched_urgent_count, v->processor));
}
}
}
@@ -233,7 +235,7 @@ static inline void vcpu_runstate_change(
s_time_t delta;
ASSERT(v->runstate.state != new_state);
- ASSERT(spin_is_locked(per_cpu(schedule_data,v->processor).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(v->processor)->schedule_lock));
vcpu_urgent_count_update(v);
@@ -393,7 +395,7 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
/* Idle VCPUs are scheduled immediately, so don't put them in runqueue. */
if ( is_idle_domain(d) )
{
- per_cpu(schedule_data, v->processor).curr = unit;
+ get_sched_res(v->processor)->curr = unit;
v->is_running = 1;
}
else
@@ -518,7 +520,7 @@ void sched_destroy_vcpu(struct vcpu *v)
kill_timer(&v->singleshot_timer);
kill_timer(&v->poll_timer);
if ( test_and_clear_bool(v->is_urgent) )
- atomic_dec(&per_cpu(schedule_data, v->processor).urgent_count);
+ atomic_dec(&per_cpu(sched_urgent_count, v->processor));
sched_remove_unit(vcpu_scheduler(v), unit);
sched_free_vdata(vcpu_scheduler(v), unit->priv);
sched_free_unit(unit);
@@ -565,7 +567,7 @@ void sched_destroy_domain(struct domain *d)
void vcpu_sleep_nosync_locked(struct vcpu *v)
{
- ASSERT(spin_is_locked(per_cpu(schedule_data,v->processor).schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(v->processor)->schedule_lock));
if ( likely(!vcpu_runnable(v)) )
{
@@ -660,8 +662,8 @@ static void vcpu_move_locked(struct vcpu *v, unsigned int new_cpu)
*/
if ( unlikely(v->is_urgent) && (old_cpu != new_cpu) )
{
- atomic_inc(&per_cpu(schedule_data, new_cpu).urgent_count);
- atomic_dec(&per_cpu(schedule_data, old_cpu).urgent_count);
+ atomic_inc(&per_cpu(sched_urgent_count, new_cpu));
+ atomic_dec(&per_cpu(sched_urgent_count, old_cpu));
}
/*
@@ -727,20 +729,20 @@ static void vcpu_migrate_finish(struct vcpu *v)
* are not correct any longer after evaluating old and new cpu holding
* the locks.
*/
- old_lock = per_cpu(schedule_data, old_cpu).schedule_lock;
- new_lock = per_cpu(schedule_data, new_cpu).schedule_lock;
+ old_lock = get_sched_res(old_cpu)->schedule_lock;
+ new_lock = get_sched_res(new_cpu)->schedule_lock;
sched_spin_lock_double(old_lock, new_lock, &flags);
old_cpu = v->processor;
- if ( old_lock == per_cpu(schedule_data, old_cpu).schedule_lock )
+ if ( old_lock == get_sched_res(old_cpu)->schedule_lock )
{
/*
* If we selected a CPU on the previosu iteration, check if it
* remains suitable for running this vCPU.
*/
if ( pick_called &&
- (new_lock == per_cpu(schedule_data, new_cpu).schedule_lock) &&
+ (new_lock == get_sched_res(new_cpu)->schedule_lock) &&
cpumask_test_cpu(new_cpu, v->cpu_hard_affinity) &&
cpumask_test_cpu(new_cpu, v->domain->cpupool->cpu_valid) )
break;
@@ -748,7 +750,7 @@ static void vcpu_migrate_finish(struct vcpu *v)
/* Select a new CPU. */
new_cpu = sched_pick_resource(vcpu_scheduler(v),
v->sched_unit)->master_cpu;
- if ( (new_lock == per_cpu(schedule_data, new_cpu).schedule_lock) &&
+ if ( (new_lock == get_sched_res(new_cpu)->schedule_lock) &&
cpumask_test_cpu(new_cpu, v->domain->cpupool->cpu_valid) )
break;
pick_called = 1;
@@ -1565,7 +1567,7 @@ static void schedule(void)
struct scheduler *sched;
unsigned long *tasklet_work = &this_cpu(tasklet_work_to_do);
bool_t tasklet_work_scheduled = 0;
- struct schedule_data *sd;
+ struct sched_resource *sd;
spinlock_t *lock;
struct task_slice next_slice;
int cpu = smp_processor_id();
@@ -1574,7 +1576,7 @@ static void schedule(void)
SCHED_STAT_CRANK(sched_run);
- sd = &this_cpu(schedule_data);
+ sd = get_sched_res(cpu);
/* Update tasklet scheduling status. */
switch ( *tasklet_work )
@@ -1715,20 +1717,19 @@ static void poll_timer_fn(void *data)
static int cpu_schedule_up(unsigned int cpu)
{
- struct schedule_data *sd = &per_cpu(schedule_data, cpu);
- struct sched_resource *res;
+ struct sched_resource *sd;
- res = xzalloc(struct sched_resource);
- if ( res == NULL )
+ sd = xzalloc(struct sched_resource);
+ if ( sd == NULL )
return -ENOMEM;
- res->master_cpu = cpu;
- set_sched_res(cpu, res);
+ sd->master_cpu = cpu;
+ set_sched_res(cpu, sd);
per_cpu(scheduler, cpu) = &sched_idle_ops;
spin_lock_init(&sd->_lock);
sd->schedule_lock = &sched_free_cpu_lock;
init_timer(&sd->s_timer, s_timer_fn, NULL, cpu);
- atomic_set(&sd->urgent_count, 0);
+ atomic_set(&per_cpu(sched_urgent_count, cpu), 0);
/* Boot CPU is dealt with later in scheduler_init(). */
if ( cpu == 0 )
@@ -1737,7 +1738,7 @@ static int cpu_schedule_up(unsigned int cpu)
if ( idle_vcpu[cpu] == NULL )
vcpu_create(idle_vcpu[0]->domain, cpu, cpu);
else
- idle_vcpu[cpu]->sched_unit->res = res;
+ idle_vcpu[cpu]->sched_unit->res = sd;
if ( idle_vcpu[cpu] == NULL )
return -ENOMEM;
@@ -1757,7 +1758,7 @@ static int cpu_schedule_up(unsigned int cpu)
static void cpu_schedule_down(unsigned int cpu)
{
- struct schedule_data *sd = &per_cpu(schedule_data, cpu);
+ struct sched_resource *sd = get_sched_res(cpu);
kill_timer(&sd->s_timer);
@@ -1916,7 +1917,7 @@ void __init scheduler_init(void)
idle_domain->max_vcpus = nr_cpu_ids;
if ( vcpu_create(idle_domain, 0, 0) == NULL )
BUG();
- this_cpu(schedule_data).curr = idle_vcpu[0]->sched_unit;
+ get_sched_res(0)->curr = idle_vcpu[0]->sched_unit;
}
/*
@@ -1933,7 +1934,7 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c)
struct scheduler *old_ops = per_cpu(scheduler, cpu);
struct scheduler *new_ops = (c == NULL) ? &sched_idle_ops : c->sched;
struct cpupool *old_pool = per_cpu(cpupool, cpu);
- struct schedule_data *sd = &per_cpu(schedule_data, cpu);
+ struct sched_resource *sd = get_sched_res(cpu);
spinlock_t *old_lock, *new_lock;
unsigned long flags;
diff --git a/xen/include/asm-x86/cpuidle.h b/xen/include/asm-x86/cpuidle.h
index 488f708305..5d7dffd228 100644
--- a/xen/include/asm-x86/cpuidle.h
+++ b/xen/include/asm-x86/cpuidle.h
@@ -4,7 +4,6 @@
#include <xen/cpuidle.h>
#include <xen/notifier.h>
#include <xen/sched.h>
-#include <xen/sched-if.h>
extern struct acpi_processor_power *processor_powers[];
@@ -27,14 +26,4 @@ void update_idle_stats(struct acpi_processor_power *,
void update_last_cx_stat(struct acpi_processor_power *,
struct acpi_processor_cx *, uint64_t);
-/*
- * vcpu is urgent if vcpu is polling event channel
- *
- * if urgent vcpu exists, CPU should not enter deep C state
- */
-static inline int sched_has_urgent_vcpu(void)
-{
- return atomic_read(&this_cpu(schedule_data).urgent_count);
-}
-
#endif /* __X86_ASM_CPUIDLE_H__ */
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 6aa8d125c8..2b152d1c75 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -33,22 +33,19 @@ extern int sched_ratelimit_us;
* For cache betterness, keep the actual lock in the same cache area
* as the rest of the struct. Just have the scheduler point to the
* one it wants (This may be the one right in front of it).*/
-struct schedule_data {
+struct sched_resource {
spinlock_t *schedule_lock,
_lock;
struct sched_unit *curr;
void *sched_priv;
struct timer s_timer; /* scheduling timer */
- atomic_t urgent_count; /* how many urgent vcpus */
-};
-
-#define curr_on_cpu(c) (per_cpu(schedule_data, c).curr)
-struct sched_resource {
- unsigned int master_cpu; /* Cpu with lowest id in scheduling resource. */
+ /* Cpu with lowest id in scheduling resource. */
+ unsigned int master_cpu;
};
-DECLARE_PER_CPU(struct schedule_data, schedule_data);
+#define curr_on_cpu(c) (get_sched_res(c)->curr)
+
DECLARE_PER_CPU(struct scheduler *, scheduler);
DECLARE_PER_CPU(struct cpupool *, cpupool);
DECLARE_PER_CPU(struct sched_resource *, sched_res);
@@ -79,7 +76,7 @@ static inline spinlock_t *kind##_schedule_lock##irq(param EXTRA_TYPE(arg)) \
{ \
for ( ; ; ) \
{ \
- spinlock_t *lock = per_cpu(schedule_data, cpu).schedule_lock; \
+ spinlock_t *lock = get_sched_res(cpu)->schedule_lock; \
/* \
* v->processor may change when grabbing the lock; but \
* per_cpu(v->processor) may also change, if changing cpu pool \
@@ -89,7 +86,7 @@ static inline spinlock_t *kind##_schedule_lock##irq(param EXTRA_TYPE(arg)) \
* lock may be the same; this will succeed in that case. \
*/ \
spin_lock##irq(lock, ## arg); \
- if ( likely(lock == per_cpu(schedule_data, cpu).schedule_lock) ) \
+ if ( likely(lock == get_sched_res(cpu)->schedule_lock) ) \
return lock; \
spin_unlock##irq(lock, ## arg); \
} \
@@ -99,7 +96,7 @@ static inline spinlock_t *kind##_schedule_lock##irq(param EXTRA_TYPE(arg)) \
static inline void kind##_schedule_unlock##irq(spinlock_t *lock \
EXTRA_TYPE(arg), param) \
{ \
- ASSERT(lock == per_cpu(schedule_data, cpu).schedule_lock); \
+ ASSERT(lock == get_sched_res(cpu)->schedule_lock); \
spin_unlock##irq(lock, ## arg); \
}
@@ -128,11 +125,11 @@ sched_unlock(vcpu, const struct vcpu *v, v->processor, _irqrestore, flags)
static inline spinlock_t *pcpu_schedule_trylock(unsigned int cpu)
{
- spinlock_t *lock = per_cpu(schedule_data, cpu).schedule_lock;
+ spinlock_t *lock = get_sched_res(cpu)->schedule_lock;
if ( !spin_trylock(lock) )
return NULL;
- if ( lock == per_cpu(schedule_data, cpu).schedule_lock )
+ if ( lock == get_sched_res(cpu)->schedule_lock )
return lock;
spin_unlock(lock);
return NULL;
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 999e43e8cc..8780888603 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -881,6 +881,17 @@ static inline struct vcpu *domain_vcpu(const struct domain *d,
void cpu_init(void);
+/*
+ * vcpu is urgent if vcpu is polling event channel
+ *
+ * if urgent vcpu exists, CPU should not enter deep C state
+ */
+DECLARE_PER_CPU(atomic_t, sched_urgent_count);
+static inline bool sched_has_urgent_vcpu(void)
+{
+ return atomic_read(&this_cpu(sched_urgent_count));
+}
+
struct scheduler;
struct scheduler *scheduler_get_default(void);
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 08/47] xen/sched: switch vcpu_schedule_lock to unit_schedule_lock
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (6 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 17:18 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 09/47] xen/sched: move some per-vcpu items to struct sched_unit Juergen Gross
` (40 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Meng Xu, Jan Beulich
Rename vcpu_schedule_[un]lock[_irq]() to unit_schedule_[un]lock[_irq]()
and let it take a sched_unit pointer instead of a vcpu pointer as
parameter.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/sched_credit.c | 17 +++++++++--------
xen/common/sched_credit2.c | 40 ++++++++++++++++++++--------------------
xen/common/sched_null.c | 16 ++++++++--------
xen/common/sched_rt.c | 15 +++++++--------
xen/common/schedule.c | 45 +++++++++++++++++++++++----------------------
xen/include/xen/sched-if.h | 12 ++++++------
6 files changed, 73 insertions(+), 72 deletions(-)
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index ee42de6bce..7621a5527e 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -926,7 +926,8 @@ __csched_vcpu_acct_stop_locked(struct csched_private *prv,
static void
csched_vcpu_acct(struct csched_private *prv, unsigned int cpu)
{
- struct csched_unit * const svc = CSCHED_UNIT(current->sched_unit);
+ struct sched_unit *currunit = current->sched_unit;
+ struct csched_unit * const svc = CSCHED_UNIT(currunit);
const struct scheduler *ops = per_cpu(scheduler, cpu);
ASSERT( current->processor == cpu );
@@ -962,7 +963,7 @@ csched_vcpu_acct(struct csched_private *prv, unsigned int cpu)
{
unsigned int new_cpu;
unsigned long flags;
- spinlock_t *lock = vcpu_schedule_lock_irqsave(current, &flags);
+ spinlock_t *lock = unit_schedule_lock_irqsave(currunit, &flags);
/*
* If it's been active a while, check if we'd be better off
@@ -971,7 +972,7 @@ csched_vcpu_acct(struct csched_private *prv, unsigned int cpu)
*/
new_cpu = _csched_cpu_pick(ops, current, 0);
- vcpu_schedule_unlock_irqrestore(lock, flags, current);
+ unit_schedule_unlock_irqrestore(lock, flags, currunit);
if ( new_cpu != cpu )
{
@@ -1023,19 +1024,19 @@ csched_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
BUG_ON( is_idle_vcpu(vc) );
/* csched_res_pick() looks in vc->processor's runq, so we need the lock. */
- lock = vcpu_schedule_lock_irq(vc);
+ lock = unit_schedule_lock_irq(unit);
unit->res = csched_res_pick(ops, unit);
vc->processor = unit->res->master_cpu;
spin_unlock_irq(lock);
- lock = vcpu_schedule_lock_irq(vc);
+ lock = unit_schedule_lock_irq(unit);
if ( !__vcpu_on_runq(svc) && vcpu_runnable(vc) && !vc->is_running )
runq_insert(svc);
- vcpu_schedule_unlock_irq(lock, vc);
+ unit_schedule_unlock_irq(lock, unit);
SCHED_STAT_CRANK(vcpu_insert);
}
@@ -2133,12 +2134,12 @@ csched_dump(const struct scheduler *ops)
spinlock_t *lock;
svc = list_entry(iter_svc, struct csched_unit, active_vcpu_elem);
- lock = vcpu_schedule_lock(svc->vcpu);
+ lock = unit_schedule_lock(svc->vcpu->sched_unit);
printk("\t%3d: ", ++loop);
csched_dump_vcpu(svc);
- vcpu_schedule_unlock(lock, svc->vcpu);
+ unit_schedule_unlock(lock, svc->vcpu->sched_unit);
}
}
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 849f3a916e..4c471bf482 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -171,7 +171,7 @@
* - runqueue lock
* + it is per-runqueue, so:
* * cpus in a runqueue take the runqueue lock, when using
- * pcpu_schedule_lock() / vcpu_schedule_lock() (and friends),
+ * pcpu_schedule_lock() / unit_schedule_lock() (and friends),
* * a cpu may (try to) take a "remote" runqueue lock, e.g., for
* load balancing;
* + serializes runqueue operations (removing and inserting vcpus);
@@ -1891,7 +1891,7 @@ unpark_parked_vcpus(const struct scheduler *ops, struct list_head *vcpus)
unsigned long flags;
s_time_t now;
- lock = vcpu_schedule_lock_irqsave(svc->vcpu, &flags);
+ lock = unit_schedule_lock_irqsave(svc->vcpu->sched_unit, &flags);
__clear_bit(_VPF_parked, &svc->vcpu->pause_flags);
if ( unlikely(svc->flags & CSFLAG_scheduled) )
@@ -1924,7 +1924,7 @@ unpark_parked_vcpus(const struct scheduler *ops, struct list_head *vcpus)
}
list_del_init(&svc->parked_elem);
- vcpu_schedule_unlock_irqrestore(lock, flags, svc->vcpu);
+ unit_schedule_unlock_irqrestore(lock, flags, svc->vcpu->sched_unit);
}
}
@@ -2163,7 +2163,7 @@ csched2_context_saved(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
struct csched2_unit * const svc = csched2_unit(unit);
- spinlock_t *lock = vcpu_schedule_lock_irq(vc);
+ spinlock_t *lock = unit_schedule_lock_irq(unit);
s_time_t now = NOW();
LIST_HEAD(were_parked);
@@ -2195,7 +2195,7 @@ csched2_context_saved(const struct scheduler *ops, struct sched_unit *unit)
else if ( !is_idle_vcpu(vc) )
update_load(ops, svc->rqd, svc, -1, now);
- vcpu_schedule_unlock_irq(lock, vc);
+ unit_schedule_unlock_irq(lock, unit);
unpark_parked_vcpus(ops, &were_parked);
}
@@ -2848,14 +2848,14 @@ csched2_dom_cntl(
for_each_vcpu ( d, v )
{
struct csched2_unit *svc = csched2_unit(v->sched_unit);
- spinlock_t *lock = vcpu_schedule_lock(svc->vcpu);
+ spinlock_t *lock = unit_schedule_lock(svc->vcpu->sched_unit);
ASSERT(svc->rqd == c2rqd(ops, svc->vcpu->processor));
svc->weight = sdom->weight;
update_max_weight(svc->rqd, svc->weight, old_weight);
- vcpu_schedule_unlock(lock, svc->vcpu);
+ unit_schedule_unlock(lock, svc->vcpu->sched_unit);
}
}
/* Cap */
@@ -2886,7 +2886,7 @@ csched2_dom_cntl(
for_each_vcpu ( d, v )
{
svc = csched2_unit(v->sched_unit);
- lock = vcpu_schedule_lock(svc->vcpu);
+ lock = unit_schedule_lock(svc->vcpu->sched_unit);
/*
* Too small quotas would in theory cause a lot of overhead,
* which then won't happen because, in csched2_runtime(),
@@ -2894,7 +2894,7 @@ csched2_dom_cntl(
*/
svc->budget_quota = max(sdom->tot_budget / sdom->nr_vcpus,
CSCHED2_MIN_TIMER);
- vcpu_schedule_unlock(lock, svc->vcpu);
+ unit_schedule_unlock(lock, svc->vcpu->sched_unit);
}
if ( sdom->cap == 0 )
@@ -2929,7 +2929,7 @@ csched2_dom_cntl(
for_each_vcpu ( d, v )
{
svc = csched2_unit(v->sched_unit);
- lock = vcpu_schedule_lock(svc->vcpu);
+ lock = unit_schedule_lock(svc->vcpu->sched_unit);
if ( v->is_running )
{
unsigned int cpu = v->processor;
@@ -2960,7 +2960,7 @@ csched2_dom_cntl(
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
}
svc->budget = 0;
- vcpu_schedule_unlock(lock, svc->vcpu);
+ unit_schedule_unlock(lock, svc->vcpu->sched_unit);
}
}
@@ -2976,12 +2976,12 @@ csched2_dom_cntl(
for_each_vcpu ( d, v )
{
struct csched2_unit *svc = csched2_unit(v->sched_unit);
- spinlock_t *lock = vcpu_schedule_lock(svc->vcpu);
+ spinlock_t *lock = unit_schedule_lock(svc->vcpu->sched_unit);
svc->budget = STIME_MAX;
svc->budget_quota = 0;
- vcpu_schedule_unlock(lock, svc->vcpu);
+ unit_schedule_unlock(lock, svc->vcpu->sched_unit);
}
sdom->cap = 0;
/*
@@ -3120,19 +3120,19 @@ csched2_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
ASSERT(list_empty(&svc->runq_elem));
/* csched2_res_pick() expects the pcpu lock to be held */
- lock = vcpu_schedule_lock_irq(vc);
+ lock = unit_schedule_lock_irq(unit);
unit->res = csched2_res_pick(ops, unit);
vc->processor = unit->res->master_cpu;
spin_unlock_irq(lock);
- lock = vcpu_schedule_lock_irq(vc);
+ lock = unit_schedule_lock_irq(unit);
/* Add vcpu to runqueue of initial processor */
runq_assign(ops, vc);
- vcpu_schedule_unlock_irq(lock, vc);
+ unit_schedule_unlock_irq(lock, unit);
sdom->nr_vcpus++;
@@ -3162,11 +3162,11 @@ csched2_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
SCHED_STAT_CRANK(vcpu_remove);
/* Remove from runqueue */
- lock = vcpu_schedule_lock_irq(vc);
+ lock = unit_schedule_lock_irq(unit);
runq_deassign(ops, vc);
- vcpu_schedule_unlock_irq(lock, vc);
+ unit_schedule_unlock_irq(lock, unit);
svc->sdom->nr_vcpus--;
}
@@ -3750,12 +3750,12 @@ csched2_dump(const struct scheduler *ops)
struct csched2_unit * const svc = csched2_unit(v->sched_unit);
spinlock_t *lock;
- lock = vcpu_schedule_lock(svc->vcpu);
+ lock = unit_schedule_lock(svc->vcpu->sched_unit);
printk("\t%3d: ", ++loop);
csched2_dump_vcpu(prv, svc);
- vcpu_schedule_unlock(lock, svc->vcpu);
+ unit_schedule_unlock(lock, svc->vcpu->sched_unit);
}
}
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index e7ba55c650..b7700c91a2 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -309,7 +309,7 @@ pick_res(struct null_private *prv, const struct sched_unit *unit)
* all the pCPUs are busy.
*
* In fact, there must always be something sane in v->processor, or
- * vcpu_schedule_lock() and friends won't work. This is not a problem,
+ * unit_schedule_lock() and friends won't work. This is not a problem,
* as we will actually assign the vCPU to the pCPU we return from here,
* only if the pCPU is free.
*/
@@ -450,11 +450,11 @@ static void null_unit_insert(const struct scheduler *ops,
ASSERT(!is_idle_vcpu(v));
- lock = vcpu_schedule_lock_irq(v);
+ lock = unit_schedule_lock_irq(unit);
if ( unlikely(!is_vcpu_online(v)) )
{
- vcpu_schedule_unlock_irq(lock, v);
+ unit_schedule_unlock_irq(lock, unit);
return;
}
@@ -464,7 +464,7 @@ static void null_unit_insert(const struct scheduler *ops,
spin_unlock(lock);
- lock = vcpu_schedule_lock(v);
+ lock = unit_schedule_lock(unit);
cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity,
cpupool_domain_cpumask(v->domain));
@@ -513,7 +513,7 @@ static void null_unit_remove(const struct scheduler *ops,
ASSERT(!is_idle_vcpu(v));
- lock = vcpu_schedule_lock_irq(v);
+ lock = unit_schedule_lock_irq(unit);
/* If offline, the vcpu shouldn't be assigned, nor in the waitqueue */
if ( unlikely(!is_vcpu_online(v)) )
@@ -536,7 +536,7 @@ static void null_unit_remove(const struct scheduler *ops,
vcpu_deassign(prv, v);
out:
- vcpu_schedule_unlock_irq(lock, v);
+ unit_schedule_unlock_irq(lock, unit);
SCHED_STAT_CRANK(vcpu_remove);
}
@@ -935,13 +935,13 @@ static void null_dump(const struct scheduler *ops)
struct null_unit * const nvc = null_unit(v->sched_unit);
spinlock_t *lock;
- lock = vcpu_schedule_lock(nvc->vcpu);
+ lock = unit_schedule_lock(nvc->vcpu->sched_unit);
printk("\t%3d: ", ++loop);
dump_vcpu(prv, nvc);
printk("\n");
- vcpu_schedule_unlock(lock, nvc->vcpu);
+ unit_schedule_unlock(lock, nvc->vcpu->sched_unit);
}
}
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index f31c7dc02c..0d419b960e 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -177,7 +177,7 @@ static void repl_timer_handler(void *data);
/*
* System-wide private data, include global RunQueue/DepletedQ
* Global lock is referenced by sched_res->schedule_lock from all
- * physical cpus. It can be grabbed via vcpu_schedule_lock_irq()
+ * physical cpus. It can be grabbed via unit_schedule_lock_irq()
*/
struct rt_private {
spinlock_t lock; /* the global coarse-grained lock */
@@ -896,7 +896,7 @@ rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
unit->res = rt_res_pick(ops, unit);
vc->processor = unit->res->master_cpu;
- lock = vcpu_schedule_lock_irq(vc);
+ lock = unit_schedule_lock_irq(unit);
now = NOW();
if ( now >= svc->cur_deadline )
@@ -909,7 +909,7 @@ rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
if ( !vc->is_running )
runq_insert(ops, svc);
}
- vcpu_schedule_unlock_irq(lock, vc);
+ unit_schedule_unlock_irq(lock, unit);
SCHED_STAT_CRANK(vcpu_insert);
}
@@ -920,7 +920,6 @@ rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
static void
rt_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct rt_unit * const svc = rt_unit(unit);
struct rt_dom * const sdom = svc->sdom;
spinlock_t *lock;
@@ -929,14 +928,14 @@ rt_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
BUG_ON( sdom == NULL );
- lock = vcpu_schedule_lock_irq(vc);
+ lock = unit_schedule_lock_irq(unit);
if ( vcpu_on_q(svc) )
q_remove(svc);
if ( vcpu_on_replq(svc) )
replq_remove(ops,svc);
- vcpu_schedule_unlock_irq(lock, vc);
+ unit_schedule_unlock_irq(lock, unit);
}
/*
@@ -1331,7 +1330,7 @@ rt_context_saved(const struct scheduler *ops, struct sched_unit *unit)
{
struct vcpu *vc = unit->vcpu_list;
struct rt_unit *svc = rt_unit(unit);
- spinlock_t *lock = vcpu_schedule_lock_irq(vc);
+ spinlock_t *lock = unit_schedule_lock_irq(unit);
__clear_bit(__RTDS_scheduled, &svc->flags);
/* not insert idle vcpu to runq */
@@ -1348,7 +1347,7 @@ rt_context_saved(const struct scheduler *ops, struct sched_unit *unit)
replq_remove(ops, svc);
out:
- vcpu_schedule_unlock_irq(lock, vc);
+ unit_schedule_unlock_irq(lock, unit);
}
/*
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 42bca8df54..fed488bc1f 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -253,7 +253,8 @@ static inline void vcpu_runstate_change(
void vcpu_runstate_get(struct vcpu *v, struct vcpu_runstate_info *runstate)
{
- spinlock_t *lock = likely(v == current) ? NULL : vcpu_schedule_lock_irq(v);
+ spinlock_t *lock = likely(v == current)
+ ? NULL : unit_schedule_lock_irq(v->sched_unit);
s_time_t delta;
memcpy(runstate, &v->runstate, sizeof(*runstate));
@@ -262,7 +263,7 @@ void vcpu_runstate_get(struct vcpu *v, struct vcpu_runstate_info *runstate)
runstate->time[runstate->state] += delta;
if ( unlikely(lock != NULL) )
- vcpu_schedule_unlock_irq(lock, v);
+ unit_schedule_unlock_irq(lock, v->sched_unit);
}
uint64_t get_cpu_idle_time(unsigned int cpu)
@@ -477,7 +478,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
migrate_timer(&v->singleshot_timer, new_p);
migrate_timer(&v->poll_timer, new_p);
- lock = vcpu_schedule_lock_irq(v);
+ lock = unit_schedule_lock_irq(v->sched_unit);
sched_set_affinity(v, &cpumask_all, &cpumask_all);
@@ -486,7 +487,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
/*
* With v->processor modified we must not
* - make any further changes assuming we hold the scheduler lock,
- * - use vcpu_schedule_unlock_irq().
+ * - use unit_schedule_unlock_irq().
*/
spin_unlock_irq(lock);
@@ -585,11 +586,11 @@ void vcpu_sleep_nosync(struct vcpu *v)
TRACE_2D(TRC_SCHED_SLEEP, v->domain->domain_id, v->vcpu_id);
- lock = vcpu_schedule_lock_irqsave(v, &flags);
+ lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
vcpu_sleep_nosync_locked(v);
- vcpu_schedule_unlock_irqrestore(lock, flags, v);
+ unit_schedule_unlock_irqrestore(lock, flags, v->sched_unit);
}
void vcpu_sleep_sync(struct vcpu *v)
@@ -609,7 +610,7 @@ void vcpu_wake(struct vcpu *v)
TRACE_2D(TRC_SCHED_WAKE, v->domain->domain_id, v->vcpu_id);
- lock = vcpu_schedule_lock_irqsave(v, &flags);
+ lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
if ( likely(vcpu_runnable(v)) )
{
@@ -623,7 +624,7 @@ void vcpu_wake(struct vcpu *v)
vcpu_runstate_change(v, RUNSTATE_offline, NOW());
}
- vcpu_schedule_unlock_irqrestore(lock, flags, v);
+ unit_schedule_unlock_irqrestore(lock, flags, v->sched_unit);
}
void vcpu_unblock(struct vcpu *v)
@@ -691,9 +692,9 @@ static void vcpu_move_locked(struct vcpu *v, unsigned int new_cpu)
* These steps are encapsulated in the following two functions; they
* should be called like this:
*
- * lock = vcpu_schedule_lock_irq(v);
+ * lock = unit_schedule_lock_irq(unit);
* vcpu_migrate_start(v);
- * vcpu_schedule_unlock_irq(lock, v)
+ * unit_schedule_unlock_irq(lock, unit)
* vcpu_migrate_finish(v);
*
* vcpu_migrate_finish() will do the work now if it can, or simply
@@ -812,7 +813,7 @@ void restore_vcpu_affinity(struct domain *d)
* set v->processor of each of their vCPUs to something that will
* make sense for the scheduler of the cpupool in which they are in.
*/
- lock = vcpu_schedule_lock_irq(v);
+ lock = unit_schedule_lock_irq(v->sched_unit);
cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity,
cpupool_domain_cpumask(d));
@@ -841,7 +842,7 @@ void restore_vcpu_affinity(struct domain *d)
spin_unlock_irq(lock);
/* v->processor might have changed, so reacquire the lock. */
- lock = vcpu_schedule_lock_irq(v);
+ lock = unit_schedule_lock_irq(v->sched_unit);
v->sched_unit->res = sched_pick_resource(vcpu_scheduler(v),
v->sched_unit);
v->processor = v->sched_unit->res->master_cpu;
@@ -876,7 +877,7 @@ int cpu_disable_scheduler(unsigned int cpu)
for_each_vcpu ( d, v )
{
unsigned long flags;
- spinlock_t *lock = vcpu_schedule_lock_irqsave(v, &flags);
+ spinlock_t *lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
cpumask_and(&online_affinity, v->cpu_hard_affinity, c->cpu_valid);
if ( cpumask_empty(&online_affinity) &&
@@ -885,7 +886,7 @@ int cpu_disable_scheduler(unsigned int cpu)
if ( v->affinity_broken )
{
/* The vcpu is temporarily pinned, can't move it. */
- vcpu_schedule_unlock_irqrestore(lock, flags, v);
+ unit_schedule_unlock_irqrestore(lock, flags, v->sched_unit);
ret = -EADDRINUSE;
break;
}
@@ -898,7 +899,7 @@ int cpu_disable_scheduler(unsigned int cpu)
if ( v->processor != cpu )
{
/* The vcpu is not on this cpu, so we can move on. */
- vcpu_schedule_unlock_irqrestore(lock, flags, v);
+ unit_schedule_unlock_irqrestore(lock, flags, v->sched_unit);
continue;
}
@@ -911,7 +912,7 @@ int cpu_disable_scheduler(unsigned int cpu)
* things would have failed before getting in here.
*/
vcpu_migrate_start(v);
- vcpu_schedule_unlock_irqrestore(lock, flags, v);
+ unit_schedule_unlock_irqrestore(lock, flags, v->sched_unit);
vcpu_migrate_finish(v);
@@ -975,7 +976,7 @@ static int vcpu_set_affinity(
spinlock_t *lock;
int ret = 0;
- lock = vcpu_schedule_lock_irq(v);
+ lock = unit_schedule_lock_irq(v->sched_unit);
if ( v->affinity_broken )
ret = -EBUSY;
@@ -997,7 +998,7 @@ static int vcpu_set_affinity(
vcpu_migrate_start(v);
}
- vcpu_schedule_unlock_irq(lock, v);
+ unit_schedule_unlock_irq(lock, v->sched_unit);
domain_update_node_affinity(v->domain);
@@ -1129,10 +1130,10 @@ static long do_poll(struct sched_poll *sched_poll)
long vcpu_yield(void)
{
struct vcpu * v=current;
- spinlock_t *lock = vcpu_schedule_lock_irq(v);
+ spinlock_t *lock = unit_schedule_lock_irq(v->sched_unit);
sched_yield(vcpu_scheduler(v), v->sched_unit);
- vcpu_schedule_unlock_irq(lock, v);
+ unit_schedule_unlock_irq(lock, v->sched_unit);
SCHED_STAT_CRANK(vcpu_yield);
@@ -1229,7 +1230,7 @@ int vcpu_temporary_affinity(struct vcpu *v, unsigned int cpu, uint8_t reason)
int ret = -EINVAL;
bool migrate;
- lock = vcpu_schedule_lock_irq(v);
+ lock = unit_schedule_lock_irq(v->sched_unit);
if ( cpu == NR_CPUS )
{
@@ -1262,7 +1263,7 @@ int vcpu_temporary_affinity(struct vcpu *v, unsigned int cpu, uint8_t reason)
if ( migrate )
vcpu_migrate_start(v);
- vcpu_schedule_unlock_irq(lock, v);
+ unit_schedule_unlock_irq(lock, v->sched_unit);
if ( migrate )
vcpu_migrate_finish(v);
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 2b152d1c75..b8cc379e3a 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -102,22 +102,22 @@ static inline void kind##_schedule_unlock##irq(spinlock_t *lock \
#define EXTRA_TYPE(arg)
sched_lock(pcpu, unsigned int cpu, cpu, )
-sched_lock(vcpu, const struct vcpu *v, v->processor, )
+sched_lock(unit, const struct sched_unit *i, i->res->master_cpu, )
sched_lock(pcpu, unsigned int cpu, cpu, _irq)
-sched_lock(vcpu, const struct vcpu *v, v->processor, _irq)
+sched_lock(unit, const struct sched_unit *i, i->res->master_cpu, _irq)
sched_unlock(pcpu, unsigned int cpu, cpu, )
-sched_unlock(vcpu, const struct vcpu *v, v->processor, )
+sched_unlock(unit, const struct sched_unit *i, i->res->master_cpu, )
sched_unlock(pcpu, unsigned int cpu, cpu, _irq)
-sched_unlock(vcpu, const struct vcpu *v, v->processor, _irq)
+sched_unlock(unit, const struct sched_unit *i, i->res->master_cpu, _irq)
#undef EXTRA_TYPE
#define EXTRA_TYPE(arg) , unsigned long arg
#define spin_unlock_irqsave spin_unlock_irqrestore
sched_lock(pcpu, unsigned int cpu, cpu, _irqsave, *flags)
-sched_lock(vcpu, const struct vcpu *v, v->processor, _irqsave, *flags)
+sched_lock(unit, const struct sched_unit *i, i->res->master_cpu, _irqsave, *flags)
#undef spin_unlock_irqsave
sched_unlock(pcpu, unsigned int cpu, cpu, _irqrestore, flags)
-sched_unlock(vcpu, const struct vcpu *v, v->processor, _irqrestore, flags)
+sched_unlock(unit, const struct sched_unit *i, i->res->master_cpu, _irqrestore, flags)
#undef EXTRA_TYPE
#undef sched_unlock
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 09/47] xen/sched: move some per-vcpu items to struct sched_unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (7 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 08/47] xen/sched: switch vcpu_schedule_lock to unit_schedule_lock Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-19 15:38 ` Jan Beulich
2019-09-24 17:23 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 10/47] xen/sched: add scheduler helpers hiding vcpu Juergen Gross
` (39 subsequent siblings)
48 siblings, 2 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Tim Deegan, Julien Grall, Meng Xu, Jan Beulich, Dario Faggioli
Affinities are scheduler specific attributes, they should be per
scheduling unit. So move all affinity related fields in struct vcpu
to struct sched_unit. While at it switch affinity related functions in
sched-if.h to use a pointer to sched_unit instead to vcpu as parameter.
The affinity_broken flag must be kept per vcpu as it is related to
guest actions on specific vcpus. When support of multiple vcpus per
sched_unit is being added, a unit is regarded as being subject to
"broken affinity" when any of its vcpus has the affinity_broken flag
set.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V2:
- move affinity_broken back to struct vcpu (Jan Beulich)
- print affinities only once per unit (Jan Beulich)
---
xen/common/domain.c | 15 ++------
xen/common/domctl.c | 13 ++++---
xen/common/keyhandler.c | 58 ++++++++++++++++--------------
xen/common/sched_credit.c | 18 +++++-----
xen/common/sched_credit2.c | 42 +++++++++++-----------
xen/common/sched_null.c | 18 +++++-----
xen/common/sched_rt.c | 9 ++---
xen/common/schedule.c | 90 ++++++++++++++++++++++++++++------------------
xen/include/xen/sched-if.h | 17 ++++-----
xen/include/xen/sched.h | 22 ++++++------
10 files changed, 163 insertions(+), 139 deletions(-)
diff --git a/xen/common/domain.c b/xen/common/domain.c
index 0cff749bbe..8c782ee03f 100644
--- a/xen/common/domain.c
+++ b/xen/common/domain.c
@@ -132,10 +132,6 @@ static void vcpu_info_reset(struct vcpu *v)
static void vcpu_destroy(struct vcpu *v)
{
- free_cpumask_var(v->cpu_hard_affinity);
- free_cpumask_var(v->cpu_hard_affinity_saved);
- free_cpumask_var(v->cpu_soft_affinity);
-
free_vcpu_struct(v);
}
@@ -159,11 +155,6 @@ struct vcpu *vcpu_create(
grant_table_init_vcpu(v);
- if ( !zalloc_cpumask_var(&v->cpu_hard_affinity) ||
- !zalloc_cpumask_var(&v->cpu_hard_affinity_saved) ||
- !zalloc_cpumask_var(&v->cpu_soft_affinity) )
- goto fail;
-
if ( is_idle_domain(d) )
{
v->runstate.state = RUNSTATE_running;
@@ -203,7 +194,6 @@ struct vcpu *vcpu_create(
sched_destroy_vcpu(v);
fail_wq:
destroy_waitqueue_vcpu(v);
- fail:
vcpu_destroy(v);
return NULL;
@@ -600,9 +590,10 @@ void domain_update_node_affinity(struct domain *d)
*/
for_each_vcpu ( d, v )
{
- cpumask_or(dom_cpumask, dom_cpumask, v->cpu_hard_affinity);
+ cpumask_or(dom_cpumask, dom_cpumask,
+ v->sched_unit->cpu_hard_affinity);
cpumask_or(dom_cpumask_soft, dom_cpumask_soft,
- v->cpu_soft_affinity);
+ v->sched_unit->cpu_soft_affinity);
}
/* Filter out non-online cpus */
cpumask_and(dom_cpumask, dom_cpumask, online);
diff --git a/xen/common/domctl.c b/xen/common/domctl.c
index 6e6e9b9866..2f9768f08f 100644
--- a/xen/common/domctl.c
+++ b/xen/common/domctl.c
@@ -606,6 +606,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl)
case XEN_DOMCTL_getvcpuaffinity:
{
struct vcpu *v;
+ const struct sched_unit *unit;
struct xen_domctl_vcpuaffinity *vcpuaff = &op->u.vcpuaffinity;
ret = -EINVAL;
@@ -616,6 +617,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl)
if ( (v = d->vcpu[vcpuaff->vcpu]) == NULL )
break;
+ unit = v->sched_unit;
ret = -EINVAL;
if ( vcpuaffinity_params_invalid(vcpuaff) )
break;
@@ -635,7 +637,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl)
ret = -ENOMEM;
break;
}
- cpumask_copy(old_affinity, v->cpu_hard_affinity);
+ cpumask_copy(old_affinity, unit->cpu_hard_affinity);
if ( !alloc_cpumask_var(&new_affinity) )
{
@@ -668,7 +670,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl)
* For hard affinity, what we return is the intersection of
* cpupool's online mask and the new hard affinity.
*/
- cpumask_and(new_affinity, online, v->cpu_hard_affinity);
+ cpumask_and(new_affinity, online, unit->cpu_hard_affinity);
ret = cpumask_to_xenctl_bitmap(&vcpuaff->cpumap_hard,
new_affinity);
}
@@ -697,7 +699,8 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl)
* hard affinity.
*/
cpumask_and(new_affinity, new_affinity, online);
- cpumask_and(new_affinity, new_affinity, v->cpu_hard_affinity);
+ cpumask_and(new_affinity, new_affinity,
+ unit->cpu_hard_affinity);
ret = cpumask_to_xenctl_bitmap(&vcpuaff->cpumap_soft,
new_affinity);
}
@@ -710,10 +713,10 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl)
{
if ( vcpuaff->flags & XEN_VCPUAFFINITY_HARD )
ret = cpumask_to_xenctl_bitmap(&vcpuaff->cpumap_hard,
- v->cpu_hard_affinity);
+ unit->cpu_hard_affinity);
if ( vcpuaff->flags & XEN_VCPUAFFINITY_SOFT )
ret = cpumask_to_xenctl_bitmap(&vcpuaff->cpumap_soft,
- v->cpu_soft_affinity);
+ unit->cpu_soft_affinity);
}
break;
}
diff --git a/xen/common/keyhandler.c b/xen/common/keyhandler.c
index c36baa4dff..0317ae1561 100644
--- a/xen/common/keyhandler.c
+++ b/xen/common/keyhandler.c
@@ -251,6 +251,7 @@ static void reboot_machine(unsigned char key, struct cpu_user_regs *regs)
static void dump_domains(unsigned char key)
{
struct domain *d;
+ struct sched_unit *unit;
struct vcpu *v;
s_time_t now = NOW();
@@ -297,33 +298,38 @@ static void dump_domains(unsigned char key)
printk("VCPU information and callbacks for domain %u:\n",
d->domain_id);
- for_each_vcpu ( d, v )
- {
- if ( !(v->vcpu_id & 0x3f) )
- process_pending_softirqs();
- printk(" VCPU%d: CPU%d [has=%c] poll=%d "
- "upcall_pend=%02x upcall_mask=%02x ",
- v->vcpu_id, v->processor,
- v->is_running ? 'T':'F', v->poll_evtchn,
- vcpu_info(v, evtchn_upcall_pending),
- !vcpu_event_delivery_is_enabled(v));
- if ( vcpu_cpu_dirty(v) )
- printk("dirty_cpu=%u", v->dirty_cpu);
- printk("\n");
- printk(" cpu_hard_affinity={%*pbl} cpu_soft_affinity={%*pbl}\n",
- CPUMASK_PR(v->cpu_hard_affinity),
- CPUMASK_PR(v->cpu_soft_affinity));
- printk(" pause_count=%d pause_flags=%lx\n",
- atomic_read(&v->pause_count), v->pause_flags);
- arch_dump_vcpu_info(v);
-
- if ( v->periodic_period == 0 )
- printk("No periodic timer\n");
- else
- printk("%"PRI_stime" Hz periodic timer (period %"PRI_stime" ms)\n",
- 1000000000 / v->periodic_period,
- v->periodic_period / 1000000);
+ for_each_sched_unit ( d, unit )
+ {
+ printk(" UNIT%d affinities: hard={%*pbl} soft={%*pbl}\n",
+ unit->unit_id, CPUMASK_PR(unit->cpu_hard_affinity),
+ CPUMASK_PR(unit->cpu_soft_affinity));
+
+ for_each_sched_unit_vcpu ( unit, v )
+ {
+ if ( !(v->vcpu_id & 0x3f) )
+ process_pending_softirqs();
+
+ printk(" VCPU%d: CPU%d [has=%c] poll=%d "
+ "upcall_pend=%02x upcall_mask=%02x ",
+ v->vcpu_id, v->processor,
+ v->is_running ? 'T':'F', v->poll_evtchn,
+ vcpu_info(v, evtchn_upcall_pending),
+ !vcpu_event_delivery_is_enabled(v));
+ if ( vcpu_cpu_dirty(v) )
+ printk("dirty_cpu=%u", v->dirty_cpu);
+ printk("\n");
+ printk(" pause_count=%d pause_flags=%lx\n",
+ atomic_read(&v->pause_count), v->pause_flags);
+ arch_dump_vcpu_info(v);
+
+ if ( v->periodic_period == 0 )
+ printk("No periodic timer\n");
+ else
+ printk("%"PRI_stime" Hz periodic timer (period %"PRI_stime" ms)\n",
+ 1000000000 / v->periodic_period,
+ v->periodic_period / 1000000);
+ }
}
}
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index 7621a5527e..0bc1f70f32 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -352,6 +352,7 @@ DEFINE_PER_CPU(unsigned int, last_tickle_cpu);
static inline void __runq_tickle(struct csched_unit *new)
{
unsigned int cpu = new->vcpu->processor;
+ struct sched_unit *unit = new->vcpu->sched_unit;
struct csched_unit * const cur = CSCHED_UNIT(curr_on_cpu(cpu));
struct csched_private *prv = CSCHED_PRIV(per_cpu(scheduler, cpu));
cpumask_t mask, idle_mask, *online;
@@ -377,7 +378,7 @@ static inline void __runq_tickle(struct csched_unit *new)
if ( unlikely(test_bit(CSCHED_FLAG_VCPU_PINNED, &new->flags) &&
cpumask_test_cpu(cpu, &idle_mask)) )
{
- ASSERT(cpumask_cycle(cpu, new->vcpu->cpu_hard_affinity) == cpu);
+ ASSERT(cpumask_cycle(cpu, unit->cpu_hard_affinity) == cpu);
SCHED_STAT_CRANK(tickled_idle_cpu_excl);
__cpumask_set_cpu(cpu, &mask);
goto tickle;
@@ -412,11 +413,11 @@ static inline void __runq_tickle(struct csched_unit *new)
int new_idlers_empty;
if ( balance_step == BALANCE_SOFT_AFFINITY
- && !has_soft_affinity(new->vcpu) )
+ && !has_soft_affinity(unit) )
continue;
/* Are there idlers suitable for new (for this balance step)? */
- affinity_balance_cpumask(new->vcpu, balance_step,
+ affinity_balance_cpumask(unit, balance_step,
cpumask_scratch_cpu(cpu));
cpumask_and(cpumask_scratch_cpu(cpu),
cpumask_scratch_cpu(cpu), &idle_mask);
@@ -445,8 +446,7 @@ static inline void __runq_tickle(struct csched_unit *new)
*/
if ( new_idlers_empty && new->pri > cur->pri )
{
- if ( cpumask_intersects(cur->vcpu->cpu_hard_affinity,
- &idle_mask) )
+ if ( cpumask_intersects(unit->cpu_hard_affinity, &idle_mask) )
{
SCHED_VCPU_STAT_CRANK(cur, kicked_away);
SCHED_VCPU_STAT_CRANK(cur, migrate_r);
@@ -728,7 +728,7 @@ _csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc, bool_t commit)
for_each_affinity_balance_step( balance_step )
{
- affinity_balance_cpumask(vc, balance_step, cpus);
+ affinity_balance_cpumask(vc->sched_unit, balance_step, cpus);
cpumask_and(cpus, online, cpus);
/*
* We want to pick up a pcpu among the ones that are online and
@@ -747,7 +747,7 @@ _csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc, bool_t commit)
* balancing step all together.
*/
if ( balance_step == BALANCE_SOFT_AFFINITY &&
- (!has_soft_affinity(vc) || cpumask_empty(cpus)) )
+ (!has_soft_affinity(vc->sched_unit) || cpumask_empty(cpus)) )
continue;
/* If present, prefer vc's current processor */
@@ -1647,10 +1647,10 @@ csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
* or counter.
*/
if ( vc->is_running || (balance_step == BALANCE_SOFT_AFFINITY &&
- !has_soft_affinity(vc)) )
+ !has_soft_affinity(vc->sched_unit)) )
continue;
- affinity_balance_cpumask(vc, balance_step, cpumask_scratch);
+ affinity_balance_cpumask(vc->sched_unit, balance_step, cpumask_scratch);
if ( __csched_vcpu_is_migrateable(prv, vc, cpu, cpumask_scratch) )
{
/* We got a candidate. Grab it! */
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 4c471bf482..fee1471f80 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -700,10 +700,10 @@ static int get_fallback_cpu(struct csched2_unit *svc)
{
int cpu = v->processor;
- if ( bs == BALANCE_SOFT_AFFINITY && !has_soft_affinity(v) )
+ if ( bs == BALANCE_SOFT_AFFINITY && !has_soft_affinity(v->sched_unit) )
continue;
- affinity_balance_cpumask(v, bs, cpumask_scratch_cpu(cpu));
+ affinity_balance_cpumask(v->sched_unit, bs, cpumask_scratch_cpu(cpu));
cpumask_and(cpumask_scratch_cpu(cpu), cpumask_scratch_cpu(cpu),
cpupool_domain_cpumask(v->domain));
@@ -1391,10 +1391,10 @@ static s_time_t tickle_score(const struct scheduler *ops, s_time_t now,
*/
if ( score > 0 )
{
- if ( cpumask_test_cpu(cpu, new->vcpu->cpu_soft_affinity) )
+ if ( cpumask_test_cpu(cpu, new->vcpu->sched_unit->cpu_soft_affinity) )
score += CSCHED2_CREDIT_INIT;
- if ( !cpumask_test_cpu(cpu, cur->vcpu->cpu_soft_affinity) )
+ if ( !cpumask_test_cpu(cpu, cur->vcpu->sched_unit->cpu_soft_affinity) )
score += CSCHED2_CREDIT_INIT;
}
@@ -1437,6 +1437,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
{
int i, ipid = -1;
s_time_t max = 0;
+ struct sched_unit *unit = new->vcpu->sched_unit;
unsigned int bs, cpu = new->vcpu->processor;
struct csched2_runqueue_data *rqd = c2rqd(ops, cpu);
cpumask_t *online = cpupool_domain_cpumask(new->vcpu->domain);
@@ -1474,7 +1475,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
cpumask_test_cpu(cpu, &rqd->idle) &&
!cpumask_test_cpu(cpu, &rqd->tickled)) )
{
- ASSERT(cpumask_cycle(cpu, new->vcpu->cpu_hard_affinity) == cpu);
+ ASSERT(cpumask_cycle(cpu, unit->cpu_hard_affinity) == cpu);
SCHED_STAT_CRANK(tickled_idle_cpu_excl);
ipid = cpu;
goto tickle;
@@ -1483,10 +1484,10 @@ runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
for_each_affinity_balance_step( bs )
{
/* Just skip first step, if we don't have a soft affinity */
- if ( bs == BALANCE_SOFT_AFFINITY && !has_soft_affinity(new->vcpu) )
+ if ( bs == BALANCE_SOFT_AFFINITY && !has_soft_affinity(unit) )
continue;
- affinity_balance_cpumask(new->vcpu, bs, cpumask_scratch_cpu(cpu));
+ affinity_balance_cpumask(unit, bs, cpumask_scratch_cpu(cpu));
/*
* First of all, consider idle cpus, checking if we can just
@@ -1558,7 +1559,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
ipid = cpu;
/* If this is in new's soft affinity, just take it */
- if ( cpumask_test_cpu(cpu, new->vcpu->cpu_soft_affinity) )
+ if ( cpumask_test_cpu(cpu, unit->cpu_soft_affinity) )
{
SCHED_STAT_CRANK(tickled_busy_cpu);
goto tickle;
@@ -2244,7 +2245,7 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
goto out;
}
- cpumask_and(cpumask_scratch_cpu(cpu), vc->cpu_hard_affinity,
+ cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
cpupool_domain_cpumask(vc->domain));
/*
@@ -2289,7 +2290,7 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
*
* Find both runqueues in one pass.
*/
- has_soft = has_soft_affinity(vc);
+ has_soft = has_soft_affinity(unit);
for_each_cpu(i, &prv->active_queues)
{
struct csched2_runqueue_data *rqd;
@@ -2336,7 +2337,7 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
cpumask_t mask;
cpumask_and(&mask, cpumask_scratch_cpu(cpu), &rqd->active);
- if ( cpumask_intersects(&mask, svc->vcpu->cpu_soft_affinity) )
+ if ( cpumask_intersects(&mask, unit->cpu_soft_affinity) )
{
min_s_avgload = rqd_avgload;
min_s_rqi = i;
@@ -2358,9 +2359,9 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
* Note that, to obtain the soft-affinity mask, we "just" put what we
* have in cpumask_scratch in && with vc->cpu_soft_affinity. This is
* ok because:
- * - we know that vc->cpu_hard_affinity and vc->cpu_soft_affinity have
+ * - we know that unit->cpu_hard_affinity and ->cpu_soft_affinity have
* a non-empty intersection (because has_soft is true);
- * - we have vc->cpu_hard_affinity & cpupool_domain_cpumask() already
+ * - we have unit->cpu_hard_affinity & cpupool_domain_cpumask() already
* in cpumask_scratch, we do save a lot doing like this.
*
* It's kind of like open coding affinity_balance_cpumask() but, in
@@ -2368,7 +2369,7 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
* cpumask operations.
*/
cpumask_and(cpumask_scratch_cpu(cpu), cpumask_scratch_cpu(cpu),
- vc->cpu_soft_affinity);
+ unit->cpu_soft_affinity);
cpumask_and(cpumask_scratch_cpu(cpu), cpumask_scratch_cpu(cpu),
&prv->rqd[min_s_rqi].active);
}
@@ -2476,6 +2477,7 @@ static void migrate(const struct scheduler *ops,
s_time_t now)
{
int cpu = svc->vcpu->processor;
+ struct sched_unit *unit = svc->vcpu->sched_unit;
if ( unlikely(tb_init_done) )
{
@@ -2513,7 +2515,7 @@ static void migrate(const struct scheduler *ops,
}
_runq_deassign(svc);
- cpumask_and(cpumask_scratch_cpu(cpu), svc->vcpu->cpu_hard_affinity,
+ cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
cpupool_domain_cpumask(svc->vcpu->domain));
cpumask_and(cpumask_scratch_cpu(cpu), cpumask_scratch_cpu(cpu),
&trqd->active);
@@ -2547,7 +2549,7 @@ static bool vcpu_is_migrateable(struct csched2_unit *svc,
struct vcpu *v = svc->vcpu;
int cpu = svc->vcpu->processor;
- cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity,
+ cpumask_and(cpumask_scratch_cpu(cpu), v->sched_unit->cpu_hard_affinity,
cpupool_domain_cpumask(v->domain));
return !(svc->flags & CSFLAG_runq_migrate_request) &&
@@ -2781,7 +2783,7 @@ csched2_unit_migrate(
/* If here, new_cpu must be a valid Credit2 pCPU, and in our affinity. */
ASSERT(cpumask_test_cpu(new_cpu, &csched2_priv(ops)->initialized));
- ASSERT(cpumask_test_cpu(new_cpu, vc->cpu_hard_affinity));
+ ASSERT(cpumask_test_cpu(new_cpu, unit->cpu_hard_affinity));
trqd = c2rqd(ops, new_cpu);
@@ -3321,9 +3323,9 @@ runq_candidate(struct csched2_runqueue_data *rqd,
}
/* If scurr has a soft-affinity, let's check whether cpu is part of it */
- if ( has_soft_affinity(scurr->vcpu) )
+ if ( has_soft_affinity(scurr->vcpu->sched_unit) )
{
- affinity_balance_cpumask(scurr->vcpu, BALANCE_SOFT_AFFINITY,
+ affinity_balance_cpumask(scurr->vcpu->sched_unit, BALANCE_SOFT_AFFINITY,
cpumask_scratch);
if ( unlikely(!cpumask_test_cpu(cpu, cpumask_scratch)) )
{
@@ -3378,7 +3380,7 @@ runq_candidate(struct csched2_runqueue_data *rqd,
}
/* Only consider vcpus that are allowed to run on this processor. */
- if ( !cpumask_test_cpu(cpu, svc->vcpu->cpu_hard_affinity) )
+ if ( !cpumask_test_cpu(cpu, svc->vcpu->sched_unit->cpu_hard_affinity) )
{
(*skipped)++;
continue;
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index b7700c91a2..1d96dc5fa5 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -122,7 +122,8 @@ static inline struct null_unit *null_unit(const struct sched_unit *unit)
static inline bool vcpu_check_affinity(struct vcpu *v, unsigned int cpu,
unsigned int balance_step)
{
- affinity_balance_cpumask(v, balance_step, cpumask_scratch_cpu(cpu));
+ affinity_balance_cpumask(v->sched_unit, balance_step,
+ cpumask_scratch_cpu(cpu));
cpumask_and(cpumask_scratch_cpu(cpu), cpumask_scratch_cpu(cpu),
cpupool_domain_cpumask(v->domain));
@@ -273,10 +274,10 @@ pick_res(struct null_private *prv, const struct sched_unit *unit)
for_each_affinity_balance_step( bs )
{
- if ( bs == BALANCE_SOFT_AFFINITY && !has_soft_affinity(v) )
+ if ( bs == BALANCE_SOFT_AFFINITY && !has_soft_affinity(unit) )
continue;
- affinity_balance_cpumask(v, bs, cpumask_scratch_cpu(cpu));
+ affinity_balance_cpumask(unit, bs, cpumask_scratch_cpu(cpu));
cpumask_and(cpumask_scratch_cpu(cpu), cpumask_scratch_cpu(cpu), cpus);
/*
@@ -313,7 +314,7 @@ pick_res(struct null_private *prv, const struct sched_unit *unit)
* as we will actually assign the vCPU to the pCPU we return from here,
* only if the pCPU is free.
*/
- cpumask_and(cpumask_scratch_cpu(cpu), cpus, v->cpu_hard_affinity);
+ cpumask_and(cpumask_scratch_cpu(cpu), cpus, unit->cpu_hard_affinity);
new_cpu = cpumask_any(cpumask_scratch_cpu(cpu));
out:
@@ -396,7 +397,8 @@ static bool vcpu_deassign(struct null_private *prv, struct vcpu *v)
{
list_for_each_entry( wvc, &prv->waitq, waitq_elem )
{
- if ( bs == BALANCE_SOFT_AFFINITY && !has_soft_affinity(wvc->vcpu) )
+ if ( bs == BALANCE_SOFT_AFFINITY &&
+ !has_soft_affinity(wvc->vcpu->sched_unit) )
continue;
if ( vcpu_check_affinity(wvc->vcpu, cpu, bs) )
@@ -466,7 +468,7 @@ static void null_unit_insert(const struct scheduler *ops,
lock = unit_schedule_lock(unit);
- cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity,
+ cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
cpupool_domain_cpumask(v->domain));
/* If the pCPU is free, we assign v to it */
@@ -579,7 +581,7 @@ static void null_unit_wake(const struct scheduler *ops,
list_add_tail(&nvc->waitq_elem, &prv->waitq);
spin_unlock(&prv->waitq_lock);
- cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity,
+ cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
cpupool_domain_cpumask(v->domain));
if ( !cpumask_intersects(&prv->cpus_free, cpumask_scratch_cpu(cpu)) )
@@ -848,7 +850,7 @@ static struct task_slice null_schedule(const struct scheduler *ops,
list_for_each_entry( wvc, &prv->waitq, waitq_elem )
{
if ( bs == BALANCE_SOFT_AFFINITY &&
- !has_soft_affinity(wvc->vcpu) )
+ !has_soft_affinity(wvc->vcpu->sched_unit) )
continue;
if ( vcpu_check_affinity(wvc->vcpu, cpu, bs) )
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index 0d419b960e..927f630531 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -327,7 +327,7 @@ rt_dump_vcpu(const struct scheduler *ops, const struct rt_unit *svc)
mask = cpumask_scratch_cpu(svc->vcpu->processor);
cpupool_mask = cpupool_domain_cpumask(svc->vcpu->domain);
- cpumask_and(mask, cpupool_mask, svc->vcpu->cpu_hard_affinity);
+ cpumask_and(mask, cpupool_mask, svc->vcpu->sched_unit->cpu_hard_affinity);
printk("[%5d.%-2u] cpu %u, (%"PRI_stime", %"PRI_stime"),"
" cur_b=%"PRI_stime" cur_d=%"PRI_stime" last_start=%"PRI_stime"\n"
" \t\t priority_level=%d has_extratime=%d\n"
@@ -644,7 +644,7 @@ rt_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
int cpu;
online = cpupool_domain_cpumask(vc->domain);
- cpumask_and(&cpus, online, vc->cpu_hard_affinity);
+ cpumask_and(&cpus, online, unit->cpu_hard_affinity);
cpu = cpumask_test_cpu(vc->processor, &cpus)
? vc->processor
@@ -1022,7 +1022,8 @@ runq_pick(const struct scheduler *ops, const cpumask_t *mask)
/* mask cpu_hard_affinity & cpupool & mask */
online = cpupool_domain_cpumask(iter_svc->vcpu->domain);
- cpumask_and(&cpu_common, online, iter_svc->vcpu->cpu_hard_affinity);
+ cpumask_and(&cpu_common, online,
+ iter_svc->vcpu->sched_unit->cpu_hard_affinity);
cpumask_and(&cpu_common, mask, &cpu_common);
if ( cpumask_empty(&cpu_common) )
continue;
@@ -1191,7 +1192,7 @@ runq_tickle(const struct scheduler *ops, struct rt_unit *new)
return;
online = cpupool_domain_cpumask(new->vcpu->domain);
- cpumask_and(¬_tickled, online, new->vcpu->cpu_hard_affinity);
+ cpumask_and(¬_tickled, online, new->vcpu->sched_unit->cpu_hard_affinity);
cpumask_andnot(¬_tickled, ¬_tickled, &prv->tickled);
/*
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index fed488bc1f..11e5c2895b 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -329,6 +329,11 @@ static void sched_free_unit(struct sched_unit *unit)
}
unit->vcpu_list->sched_unit = NULL;
+
+ free_cpumask_var(unit->cpu_hard_affinity);
+ free_cpumask_var(unit->cpu_hard_affinity_saved);
+ free_cpumask_var(unit->cpu_soft_affinity);
+
xfree(unit);
}
@@ -354,7 +359,16 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
unit->next_in_list = *prev_unit;
*prev_unit = unit;
+ if ( !zalloc_cpumask_var(&unit->cpu_hard_affinity) ||
+ !zalloc_cpumask_var(&unit->cpu_hard_affinity_saved) ||
+ !zalloc_cpumask_var(&unit->cpu_soft_affinity) )
+ goto fail;
+
return unit;
+
+ fail:
+ sched_free_unit(unit);
+ return NULL;
}
int sched_init_vcpu(struct vcpu *v, unsigned int processor)
@@ -744,7 +758,7 @@ static void vcpu_migrate_finish(struct vcpu *v)
*/
if ( pick_called &&
(new_lock == get_sched_res(new_cpu)->schedule_lock) &&
- cpumask_test_cpu(new_cpu, v->cpu_hard_affinity) &&
+ cpumask_test_cpu(new_cpu, v->sched_unit->cpu_hard_affinity) &&
cpumask_test_cpu(new_cpu, v->domain->cpupool->cpu_valid) )
break;
@@ -802,6 +816,7 @@ void restore_vcpu_affinity(struct domain *d)
{
spinlock_t *lock;
unsigned int old_cpu = v->processor;
+ struct sched_unit *unit = v->sched_unit;
ASSERT(!vcpu_runnable(v));
@@ -813,17 +828,17 @@ void restore_vcpu_affinity(struct domain *d)
* set v->processor of each of their vCPUs to something that will
* make sense for the scheduler of the cpupool in which they are in.
*/
- lock = unit_schedule_lock_irq(v->sched_unit);
+ lock = unit_schedule_lock_irq(unit);
- cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity,
+ cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
cpupool_domain_cpumask(d));
if ( cpumask_empty(cpumask_scratch_cpu(cpu)) )
{
if ( v->affinity_broken )
{
- sched_set_affinity(v, v->cpu_hard_affinity_saved, NULL);
+ sched_set_affinity(v, unit->cpu_hard_affinity_saved, NULL);
v->affinity_broken = 0;
- cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity,
+ cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
cpupool_domain_cpumask(d));
}
@@ -831,21 +846,20 @@ void restore_vcpu_affinity(struct domain *d)
{
printk(XENLOG_DEBUG "Breaking affinity for %pv\n", v);
sched_set_affinity(v, &cpumask_all, NULL);
- cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity,
+ cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
cpupool_domain_cpumask(d));
}
}
v->processor = cpumask_any(cpumask_scratch_cpu(cpu));
- v->sched_unit->res = get_sched_res(v->processor);
+ unit->res = get_sched_res(v->processor);
spin_unlock_irq(lock);
/* v->processor might have changed, so reacquire the lock. */
- lock = unit_schedule_lock_irq(v->sched_unit);
- v->sched_unit->res = sched_pick_resource(vcpu_scheduler(v),
- v->sched_unit);
- v->processor = v->sched_unit->res->master_cpu;
+ lock = unit_schedule_lock_irq(unit);
+ unit->res = sched_pick_resource(vcpu_scheduler(v), unit);
+ v->processor = unit->res->master_cpu;
spin_unlock_irq(lock);
if ( old_cpu != v->processor )
@@ -877,16 +891,17 @@ int cpu_disable_scheduler(unsigned int cpu)
for_each_vcpu ( d, v )
{
unsigned long flags;
- spinlock_t *lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
+ struct sched_unit *unit = v->sched_unit;
+ spinlock_t *lock = unit_schedule_lock_irqsave(unit, &flags);
- cpumask_and(&online_affinity, v->cpu_hard_affinity, c->cpu_valid);
+ cpumask_and(&online_affinity, unit->cpu_hard_affinity, c->cpu_valid);
if ( cpumask_empty(&online_affinity) &&
- cpumask_test_cpu(cpu, v->cpu_hard_affinity) )
+ cpumask_test_cpu(cpu, unit->cpu_hard_affinity) )
{
if ( v->affinity_broken )
{
/* The vcpu is temporarily pinned, can't move it. */
- unit_schedule_unlock_irqrestore(lock, flags, v->sched_unit);
+ unit_schedule_unlock_irqrestore(lock, flags, unit);
ret = -EADDRINUSE;
break;
}
@@ -899,7 +914,7 @@ int cpu_disable_scheduler(unsigned int cpu)
if ( v->processor != cpu )
{
/* The vcpu is not on this cpu, so we can move on. */
- unit_schedule_unlock_irqrestore(lock, flags, v->sched_unit);
+ unit_schedule_unlock_irqrestore(lock, flags, unit);
continue;
}
@@ -912,7 +927,7 @@ int cpu_disable_scheduler(unsigned int cpu)
* things would have failed before getting in here.
*/
vcpu_migrate_start(v);
- unit_schedule_unlock_irqrestore(lock, flags, v->sched_unit);
+ unit_schedule_unlock_irqrestore(lock, flags, unit);
vcpu_migrate_finish(v);
@@ -957,26 +972,29 @@ static int cpu_disable_scheduler_check(unsigned int cpu)
void sched_set_affinity(
struct vcpu *v, const cpumask_t *hard, const cpumask_t *soft)
{
- sched_adjust_affinity(dom_scheduler(v->domain), v->sched_unit, hard, soft);
+ struct sched_unit *unit = v->sched_unit;
+
+ sched_adjust_affinity(dom_scheduler(v->domain), unit, hard, soft);
if ( hard )
- cpumask_copy(v->cpu_hard_affinity, hard);
+ cpumask_copy(unit->cpu_hard_affinity, hard);
if ( soft )
- cpumask_copy(v->cpu_soft_affinity, soft);
+ cpumask_copy(unit->cpu_soft_affinity, soft);
- v->soft_aff_effective = !cpumask_subset(v->cpu_hard_affinity,
- v->cpu_soft_affinity) &&
- cpumask_intersects(v->cpu_soft_affinity,
- v->cpu_hard_affinity);
+ unit->soft_aff_effective = !cpumask_subset(unit->cpu_hard_affinity,
+ unit->cpu_soft_affinity) &&
+ cpumask_intersects(unit->cpu_soft_affinity,
+ unit->cpu_hard_affinity);
}
static int vcpu_set_affinity(
struct vcpu *v, const cpumask_t *affinity, const cpumask_t *which)
{
+ struct sched_unit *unit = v->sched_unit;
spinlock_t *lock;
int ret = 0;
- lock = unit_schedule_lock_irq(v->sched_unit);
+ lock = unit_schedule_lock_irq(unit);
if ( v->affinity_broken )
ret = -EBUSY;
@@ -986,19 +1004,19 @@ static int vcpu_set_affinity(
* Tell the scheduler we changes something about affinity,
* and ask to re-evaluate vcpu placement.
*/
- if ( which == v->cpu_hard_affinity )
+ if ( which == unit->cpu_hard_affinity )
{
sched_set_affinity(v, affinity, NULL);
}
else
{
- ASSERT(which == v->cpu_soft_affinity);
+ ASSERT(which == unit->cpu_soft_affinity);
sched_set_affinity(v, NULL, affinity);
}
vcpu_migrate_start(v);
}
- unit_schedule_unlock_irq(lock, v->sched_unit);
+ unit_schedule_unlock_irq(lock, unit);
domain_update_node_affinity(v->domain);
@@ -1017,12 +1035,12 @@ int vcpu_set_hard_affinity(struct vcpu *v, const cpumask_t *affinity)
if ( cpumask_empty(&online_affinity) )
return -EINVAL;
- return vcpu_set_affinity(v, affinity, v->cpu_hard_affinity);
+ return vcpu_set_affinity(v, affinity, v->sched_unit->cpu_hard_affinity);
}
int vcpu_set_soft_affinity(struct vcpu *v, const cpumask_t *affinity)
{
- return vcpu_set_affinity(v, affinity, v->cpu_soft_affinity);
+ return vcpu_set_affinity(v, affinity, v->sched_unit->cpu_soft_affinity);
}
/* Block the currently-executing domain until a pertinent event occurs. */
@@ -1226,11 +1244,12 @@ void watchdog_domain_destroy(struct domain *d)
*/
int vcpu_temporary_affinity(struct vcpu *v, unsigned int cpu, uint8_t reason)
{
+ struct sched_unit *unit = v->sched_unit;
spinlock_t *lock;
int ret = -EINVAL;
bool migrate;
- lock = unit_schedule_lock_irq(v->sched_unit);
+ lock = unit_schedule_lock_irq(unit);
if ( cpu == NR_CPUS )
{
@@ -1240,7 +1259,7 @@ int vcpu_temporary_affinity(struct vcpu *v, unsigned int cpu, uint8_t reason)
v->affinity_broken &= ~reason;
}
if ( !ret && !v->affinity_broken )
- sched_set_affinity(v, v->cpu_hard_affinity_saved, NULL);
+ sched_set_affinity(v, unit->cpu_hard_affinity_saved, NULL);
}
else if ( cpu < nr_cpu_ids )
{
@@ -1251,7 +1270,8 @@ int vcpu_temporary_affinity(struct vcpu *v, unsigned int cpu, uint8_t reason)
{
if ( !v->affinity_broken )
{
- cpumask_copy(v->cpu_hard_affinity_saved, v->cpu_hard_affinity);
+ cpumask_copy(unit->cpu_hard_affinity_saved,
+ unit->cpu_hard_affinity);
sched_set_affinity(v, cpumask_of(cpu), NULL);
}
v->affinity_broken |= reason;
@@ -1259,11 +1279,11 @@ int vcpu_temporary_affinity(struct vcpu *v, unsigned int cpu, uint8_t reason)
}
}
- migrate = !ret && !cpumask_test_cpu(v->processor, v->cpu_hard_affinity);
+ migrate = !ret && !cpumask_test_cpu(v->processor, unit->cpu_hard_affinity);
if ( migrate )
vcpu_migrate_start(v);
- unit_schedule_unlock_irq(lock, v->sched_unit);
+ unit_schedule_unlock_irq(lock, unit);
if ( migrate )
vcpu_migrate_finish(v);
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index b8cc379e3a..c320854527 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -439,11 +439,11 @@ static inline cpumask_t* cpupool_domain_cpumask(struct domain *d)
* * The hard affinity is not a subset of soft affinity
* * There is an overlap between the soft and hard affinity masks
*/
-static inline int has_soft_affinity(const struct vcpu *v)
+static inline int has_soft_affinity(const struct sched_unit *unit)
{
- return v->soft_aff_effective &&
- !cpumask_subset(cpupool_domain_cpumask(v->domain),
- v->cpu_soft_affinity);
+ return unit->soft_aff_effective &&
+ !cpumask_subset(cpupool_domain_cpumask(unit->domain),
+ unit->cpu_soft_affinity);
}
/*
@@ -453,17 +453,18 @@ static inline int has_soft_affinity(const struct vcpu *v)
* to avoid running a vcpu where it would like, but is not allowed to!
*/
static inline void
-affinity_balance_cpumask(const struct vcpu *v, int step, cpumask_t *mask)
+affinity_balance_cpumask(const struct sched_unit *unit, int step,
+ cpumask_t *mask)
{
if ( step == BALANCE_SOFT_AFFINITY )
{
- cpumask_and(mask, v->cpu_soft_affinity, v->cpu_hard_affinity);
+ cpumask_and(mask, unit->cpu_soft_affinity, unit->cpu_hard_affinity);
if ( unlikely(cpumask_empty(mask)) )
- cpumask_copy(mask, v->cpu_hard_affinity);
+ cpumask_copy(mask, unit->cpu_hard_affinity);
}
else /* step == BALANCE_HARD_AFFINITY */
- cpumask_copy(mask, v->cpu_hard_affinity);
+ cpumask_copy(mask, unit->cpu_hard_affinity);
}
void sched_rm_cpu(unsigned int cpu);
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 8780888603..949bb6b696 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -212,9 +212,6 @@ struct vcpu
bool hcall_compat;
#endif
- /* Does soft affinity actually play a role (given hard affinity)? */
- bool soft_aff_effective;
-
/* The CPU, if any, which is holding onto this VCPU's state. */
#define VCPU_CPU_CLEAN (~0u)
unsigned int dirty_cpu;
@@ -246,14 +243,6 @@ struct vcpu
evtchn_port_t virq_to_evtchn[NR_VIRQS];
spinlock_t virq_lock;
- /* Bitmask of CPUs on which this VCPU may run. */
- cpumask_var_t cpu_hard_affinity;
- /* Used to save affinity during temporary pinning. */
- cpumask_var_t cpu_hard_affinity_saved;
-
- /* Bitmask of CPUs on which this VCPU prefers to run. */
- cpumask_var_t cpu_soft_affinity;
-
/* Tasklet for continue_hypercall_on_cpu(). */
struct tasklet continue_hypercall_tasklet;
@@ -280,6 +269,15 @@ struct sched_unit {
struct sched_unit *next_in_list;
struct sched_resource *res;
unsigned int unit_id;
+
+ /* Does soft affinity actually play a role (given hard affinity)? */
+ bool soft_aff_effective;
+ /* Bitmask of CPUs on which this VCPU may run. */
+ cpumask_var_t cpu_hard_affinity;
+ /* Used to save affinity during temporary pinning. */
+ cpumask_var_t cpu_hard_affinity_saved;
+ /* Bitmask of CPUs on which this VCPU prefers to run. */
+ cpumask_var_t cpu_soft_affinity;
};
#define for_each_sched_unit(d, e) \
@@ -996,7 +994,7 @@ static inline bool hap_enabled(const struct domain *d)
static inline bool is_hwdom_pinned_vcpu(const struct vcpu *v)
{
return (is_hardware_domain(v->domain) &&
- cpumask_weight(v->cpu_hard_affinity) == 1);
+ cpumask_weight(v->sched_unit->cpu_hard_affinity) == 1);
}
#ifdef CONFIG_HAS_PASSTHROUGH
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 10/47] xen/sched: add scheduler helpers hiding vcpu
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (8 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 09/47] xen/sched: move some per-vcpu items to struct sched_unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-19 15:45 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 11/47] xen/sched: rename scheduler related perf counters Juergen Gross
` (38 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
Add the following helpers using a sched_unit as input instead of a
vcpu:
- is_idle_unit() similar to is_idle_vcpu()
- is_unit_online() similar to is_vcpu_online() (returns true when any
of its vcpus is online)
- unit_runnable() like vcpu_runnable() (returns true if any of its
vcpus is runnable)
- sched_set_res() to set the current scheduling resource of a unit
- sched_unit_cpu() to get the current processor of a unit (returns
the master_cpu of the scheduling resource of a unit)
- sched_{set|clear}_pause_flags[_atomic]() to modify pause_flags of the
associated vcpu(s) (modifies the pause_flags of all vcpus of the
unit)
- sched_idle_unit() to get the sched_unit pointer of the idle vcpu of a
specific physical cpu
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V3:
- make unit parameter of sched_unit_cpu() const
---
xen/common/sched_credit.c | 3 +--
xen/common/schedule.c | 21 ++++++++--------
xen/include/xen/sched-if.h | 61 +++++++++++++++++++++++++++++++++++++++++++---
3 files changed, 68 insertions(+), 17 deletions(-)
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index 0bc1f70f32..5b2c8ec0d1 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -1660,8 +1660,7 @@ csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
SCHED_STAT_CRANK(migrate_queued);
WARN_ON(vc->is_urgent);
runq_remove(speer);
- vc->processor = cpu;
- vc->sched_unit->res = get_sched_res(cpu);
+ sched_set_res(vc->sched_unit, get_sched_res(cpu));
/*
* speer will start executing directly on cpu, without having to
* go through runq_insert(). So we must update the runnable count
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 11e5c2895b..152b76ccd6 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -84,7 +84,7 @@ static spinlock_t *
sched_idle_switch_sched(struct scheduler *new_ops, unsigned int cpu,
void *pdata, void *vdata)
{
- idle_vcpu[cpu]->sched_unit->priv = NULL;
+ sched_idle_unit(cpu)->priv = NULL;
return &sched_free_cpu_lock;
}
@@ -376,12 +376,11 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
struct domain *d = v->domain;
struct sched_unit *unit;
- v->processor = processor;
-
if ( (unit = sched_alloc_unit(v)) == NULL )
return 1;
- unit->res = get_sched_res(processor);
+ sched_set_res(unit, get_sched_res(processor));
+
/* Initialise the per-vcpu timers. */
spin_lock_init(&v->periodic_timer_lock);
init_timer(&v->periodic_timer, vcpu_periodic_timer_fn,
@@ -496,8 +495,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
sched_set_affinity(v, &cpumask_all, &cpumask_all);
- v->processor = new_p;
- v->sched_unit->res = get_sched_res(new_p);
+ sched_set_res(v->sched_unit, get_sched_res(new_p));
/*
* With v->processor modified we must not
* - make any further changes assuming we hold the scheduler lock,
@@ -817,8 +815,9 @@ void restore_vcpu_affinity(struct domain *d)
spinlock_t *lock;
unsigned int old_cpu = v->processor;
struct sched_unit *unit = v->sched_unit;
+ struct sched_resource *res;
- ASSERT(!vcpu_runnable(v));
+ ASSERT(!unit_runnable(unit));
/*
* Re-assign the initial processor as after resume we have no
@@ -851,15 +850,15 @@ void restore_vcpu_affinity(struct domain *d)
}
}
- v->processor = cpumask_any(cpumask_scratch_cpu(cpu));
- unit->res = get_sched_res(v->processor);
+ res = get_sched_res(cpumask_any(cpumask_scratch_cpu(cpu)));
+ sched_set_res(unit, res);
spin_unlock_irq(lock);
/* v->processor might have changed, so reacquire the lock. */
lock = unit_schedule_lock_irq(unit);
- unit->res = sched_pick_resource(vcpu_scheduler(v), unit);
- v->processor = unit->res->master_cpu;
+ res = sched_pick_resource(vcpu_scheduler(v), unit);
+ sched_set_res(unit, res);
spin_unlock_irq(lock);
if ( old_cpu != v->processor )
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index c320854527..fa3ca51a90 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -60,6 +60,62 @@ static inline void set_sched_res(unsigned int cpu, struct sched_resource *res)
per_cpu(sched_res, cpu) = res;
}
+static inline bool is_idle_unit(const struct sched_unit *unit)
+{
+ return is_idle_vcpu(unit->vcpu_list);
+}
+
+static inline bool is_unit_online(const struct sched_unit *unit)
+{
+ return is_vcpu_online(unit->vcpu_list);
+}
+
+static inline bool unit_runnable(const struct sched_unit *unit)
+{
+ return vcpu_runnable(unit->vcpu_list);
+}
+
+static inline void sched_set_res(struct sched_unit *unit,
+ struct sched_resource *res)
+{
+ unit->vcpu_list->processor = res->master_cpu;
+ unit->res = res;
+}
+
+static inline unsigned int sched_unit_cpu(const struct sched_unit *unit)
+{
+ return unit->res->master_cpu;
+}
+
+static inline void sched_set_pause_flags(struct sched_unit *unit,
+ unsigned int bit)
+{
+ __set_bit(bit, &unit->vcpu_list->pause_flags);
+}
+
+static inline void sched_clear_pause_flags(struct sched_unit *unit,
+ unsigned int bit)
+{
+ __clear_bit(bit, &unit->vcpu_list->pause_flags);
+}
+
+static inline void sched_set_pause_flags_atomic(struct sched_unit *unit,
+ unsigned int bit)
+{
+ set_bit(bit, &unit->vcpu_list->pause_flags);
+}
+
+static inline void sched_clear_pause_flags_atomic(struct sched_unit *unit,
+ unsigned int bit)
+{
+ clear_bit(bit, &unit->vcpu_list->pause_flags);
+}
+
+static inline struct sched_unit *sched_idle_unit(unsigned int cpu)
+{
+ return idle_vcpu[cpu]->sched_unit;
+}
+
/*
* Scratch space, for avoiding having too many cpumask_t on the stack.
* Within each scheduler, when using the scratch mask of one pCPU:
@@ -346,10 +402,7 @@ static inline void sched_migrate(const struct scheduler *s,
if ( s->migrate )
s->migrate(s, unit, cpu);
else
- {
- unit->vcpu_list->processor = cpu;
- unit->res = get_sched_res(cpu);
- }
+ sched_set_res(unit, get_sched_res(cpu));
}
static inline struct sched_resource *sched_pick_resource(
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 11/47] xen/sched: rename scheduler related perf counters
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (9 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 10/47] xen/sched: add scheduler helpers hiding vcpu Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 17:25 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 12/47] xen/sched: switch struct task_slice from vcpu to sched_unit Juergen Gross
` (37 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Meng Xu, Jan Beulich
Rename the scheduler related perf counters from vcpu* to unit* where
appropriate.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/sched_credit.c | 32 ++++++++++++++++----------------
xen/common/sched_credit2.c | 18 +++++++++---------
xen/common/sched_null.c | 18 +++++++++---------
xen/common/sched_rt.c | 16 ++++++++--------
xen/include/xen/perfc_defn.h | 30 +++++++++++++++---------------
5 files changed, 57 insertions(+), 57 deletions(-)
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index 5b2c8ec0d1..e430c4efa4 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -668,7 +668,7 @@ __csched_vcpu_check(struct vcpu *vc)
BUG_ON( !is_idle_vcpu(vc) );
}
- SCHED_STAT_CRANK(vcpu_check);
+ SCHED_STAT_CRANK(unit_check);
}
#define CSCHED_VCPU_CHECK(_vc) (__csched_vcpu_check(_vc))
#else
@@ -692,7 +692,7 @@ __csched_vcpu_is_cache_hot(const struct csched_private *prv,
(NOW() - svc->last_sched_time) < prv->vcpu_migr_delay;
if ( hot )
- SCHED_STAT_CRANK(vcpu_hot);
+ SCHED_STAT_CRANK(unit_hot);
return hot;
}
@@ -881,7 +881,7 @@ __csched_vcpu_acct_start(struct csched_private *prv, struct csched_unit *svc)
if ( list_empty(&svc->active_vcpu_elem) )
{
SCHED_VCPU_STAT_CRANK(svc, state_active);
- SCHED_STAT_CRANK(acct_vcpu_active);
+ SCHED_STAT_CRANK(acct_unit_active);
sdom->active_vcpu_count++;
list_add(&svc->active_vcpu_elem, &sdom->active_vcpu);
@@ -908,7 +908,7 @@ __csched_vcpu_acct_stop_locked(struct csched_private *prv,
BUG_ON( list_empty(&svc->active_vcpu_elem) );
SCHED_VCPU_STAT_CRANK(svc, state_idle);
- SCHED_STAT_CRANK(acct_vcpu_idle);
+ SCHED_STAT_CRANK(acct_unit_idle);
BUG_ON( prv->weight < sdom->weight );
sdom->active_vcpu_count--;
@@ -1010,7 +1010,7 @@ csched_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
svc->pri = is_idle_domain(vc->domain) ?
CSCHED_PRI_IDLE : CSCHED_PRI_TS_UNDER;
SCHED_VCPU_STATS_RESET(svc);
- SCHED_STAT_CRANK(vcpu_alloc);
+ SCHED_STAT_CRANK(unit_alloc);
return svc;
}
@@ -1038,7 +1038,7 @@ csched_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
unit_schedule_unlock_irq(lock, unit);
- SCHED_STAT_CRANK(vcpu_insert);
+ SCHED_STAT_CRANK(unit_insert);
}
static void
@@ -1058,13 +1058,13 @@ csched_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
struct csched_unit * const svc = CSCHED_UNIT(unit);
struct csched_dom * const sdom = svc->sdom;
- SCHED_STAT_CRANK(vcpu_remove);
+ SCHED_STAT_CRANK(unit_remove);
ASSERT(!__vcpu_on_runq(svc));
if ( test_and_clear_bit(CSCHED_FLAG_VCPU_PARKED, &svc->flags) )
{
- SCHED_STAT_CRANK(vcpu_unpark);
+ SCHED_STAT_CRANK(unit_unpark);
vcpu_unpause(svc->vcpu);
}
@@ -1085,7 +1085,7 @@ csched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
struct csched_unit * const svc = CSCHED_UNIT(unit);
unsigned int cpu = vc->processor;
- SCHED_STAT_CRANK(vcpu_sleep);
+ SCHED_STAT_CRANK(unit_sleep);
BUG_ON( is_idle_vcpu(vc) );
@@ -1114,19 +1114,19 @@ csched_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
if ( unlikely(curr_on_cpu(vc->processor) == unit) )
{
- SCHED_STAT_CRANK(vcpu_wake_running);
+ SCHED_STAT_CRANK(unit_wake_running);
return;
}
if ( unlikely(__vcpu_on_runq(svc)) )
{
- SCHED_STAT_CRANK(vcpu_wake_onrunq);
+ SCHED_STAT_CRANK(unit_wake_onrunq);
return;
}
if ( likely(vcpu_runnable(vc)) )
- SCHED_STAT_CRANK(vcpu_wake_runnable);
+ SCHED_STAT_CRANK(unit_wake_runnable);
else
- SCHED_STAT_CRANK(vcpu_wake_not_runnable);
+ SCHED_STAT_CRANK(unit_wake_not_runnable);
/*
* We temporarly boost the priority of awaking VCPUs!
@@ -1156,7 +1156,7 @@ csched_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
!test_bit(CSCHED_FLAG_VCPU_PARKED, &svc->flags) )
{
TRACE_2D(TRC_CSCHED_BOOST_START, vc->domain->domain_id, vc->vcpu_id);
- SCHED_STAT_CRANK(vcpu_boost);
+ SCHED_STAT_CRANK(unit_boost);
svc->pri = CSCHED_PRI_TS_BOOST;
}
@@ -1515,7 +1515,7 @@ csched_acct(void* dummy)
credit < -credit_cap &&
!test_and_set_bit(CSCHED_FLAG_VCPU_PARKED, &svc->flags) )
{
- SCHED_STAT_CRANK(vcpu_park);
+ SCHED_STAT_CRANK(unit_park);
vcpu_pause_nosync(svc->vcpu);
}
@@ -1539,7 +1539,7 @@ csched_acct(void* dummy)
* call to make sure the VCPU's priority is not boosted
* if it is woken up here.
*/
- SCHED_STAT_CRANK(vcpu_unpark);
+ SCHED_STAT_CRANK(unit_unpark);
vcpu_unpause(svc->vcpu);
clear_bit(CSCHED_FLAG_VCPU_PARKED, &svc->flags);
}
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index fee1471f80..d82b7a9c75 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -2020,7 +2020,7 @@ csched2_vcpu_check(struct vcpu *vc)
{
BUG_ON( !is_idle_vcpu(vc) );
}
- SCHED_STAT_CRANK(vcpu_check);
+ SCHED_STAT_CRANK(unit_check);
}
#define CSCHED2_VCPU_CHECK(_vc) (csched2_vcpu_check(_vc))
#else
@@ -2067,7 +2067,7 @@ csched2_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
svc->budget_quota = 0;
INIT_LIST_HEAD(&svc->parked_elem);
- SCHED_STAT_CRANK(vcpu_alloc);
+ SCHED_STAT_CRANK(unit_alloc);
return svc;
}
@@ -2079,7 +2079,7 @@ csched2_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
struct csched2_unit * const svc = csched2_unit(unit);
ASSERT(!is_idle_vcpu(vc));
- SCHED_STAT_CRANK(vcpu_sleep);
+ SCHED_STAT_CRANK(unit_sleep);
if ( curr_on_cpu(vc->processor) == unit )
{
@@ -2109,20 +2109,20 @@ csched2_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
if ( unlikely(curr_on_cpu(cpu) == unit) )
{
- SCHED_STAT_CRANK(vcpu_wake_running);
+ SCHED_STAT_CRANK(unit_wake_running);
goto out;
}
if ( unlikely(vcpu_on_runq(svc)) )
{
- SCHED_STAT_CRANK(vcpu_wake_onrunq);
+ SCHED_STAT_CRANK(unit_wake_onrunq);
goto out;
}
if ( likely(vcpu_runnable(vc)) )
- SCHED_STAT_CRANK(vcpu_wake_runnable);
+ SCHED_STAT_CRANK(unit_wake_runnable);
else
- SCHED_STAT_CRANK(vcpu_wake_not_runnable);
+ SCHED_STAT_CRANK(unit_wake_not_runnable);
/* If the context hasn't been saved for this vcpu yet, we can't put it on
* another runqueue. Instead, we set a flag so that it will be put on the runqueue
@@ -3138,7 +3138,7 @@ csched2_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
sdom->nr_vcpus++;
- SCHED_STAT_CRANK(vcpu_insert);
+ SCHED_STAT_CRANK(unit_insert);
CSCHED2_VCPU_CHECK(vc);
}
@@ -3161,7 +3161,7 @@ csched2_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
ASSERT(!is_idle_vcpu(vc));
ASSERT(list_empty(&svc->runq_elem));
- SCHED_STAT_CRANK(vcpu_remove);
+ SCHED_STAT_CRANK(unit_remove);
/* Remove from runqueue */
lock = unit_schedule_lock_irq(unit);
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index 1d96dc5fa5..66f8387f11 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -199,7 +199,7 @@ static void *null_alloc_vdata(const struct scheduler *ops,
INIT_LIST_HEAD(&nvc->waitq_elem);
nvc->vcpu = v;
- SCHED_STAT_CRANK(vcpu_alloc);
+ SCHED_STAT_CRANK(unit_alloc);
return nvc;
}
@@ -502,7 +502,7 @@ static void null_unit_insert(const struct scheduler *ops,
}
spin_unlock_irq(lock);
- SCHED_STAT_CRANK(vcpu_insert);
+ SCHED_STAT_CRANK(unit_insert);
}
static void null_unit_remove(const struct scheduler *ops,
@@ -540,7 +540,7 @@ static void null_unit_remove(const struct scheduler *ops,
out:
unit_schedule_unlock_irq(lock, unit);
- SCHED_STAT_CRANK(vcpu_remove);
+ SCHED_STAT_CRANK(unit_remove);
}
static void null_unit_wake(const struct scheduler *ops,
@@ -555,21 +555,21 @@ static void null_unit_wake(const struct scheduler *ops,
if ( unlikely(curr_on_cpu(cpu) == unit) )
{
- SCHED_STAT_CRANK(vcpu_wake_running);
+ SCHED_STAT_CRANK(unit_wake_running);
return;
}
if ( unlikely(!list_empty(&nvc->waitq_elem)) )
{
/* Not exactly "on runq", but close enough for reusing the counter */
- SCHED_STAT_CRANK(vcpu_wake_onrunq);
+ SCHED_STAT_CRANK(unit_wake_onrunq);
return;
}
if ( likely(vcpu_runnable(v)) )
- SCHED_STAT_CRANK(vcpu_wake_runnable);
+ SCHED_STAT_CRANK(unit_wake_runnable);
else
- SCHED_STAT_CRANK(vcpu_wake_not_runnable);
+ SCHED_STAT_CRANK(unit_wake_not_runnable);
/*
* If a vcpu is neither on a pCPU nor in the waitqueue, it means it was
@@ -649,7 +649,7 @@ static void null_unit_sleep(const struct scheduler *ops,
if ( likely(!tickled && curr_on_cpu(cpu) == unit) )
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
- SCHED_STAT_CRANK(vcpu_sleep);
+ SCHED_STAT_CRANK(unit_sleep);
}
static struct sched_resource *
@@ -770,7 +770,7 @@ static inline void null_vcpu_check(struct vcpu *v)
else
BUG_ON(!is_idle_vcpu(v));
- SCHED_STAT_CRANK(vcpu_check);
+ SCHED_STAT_CRANK(unit_check);
}
#define NULL_VCPU_CHECK(v) (null_vcpu_check(v))
#else
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index 927f630531..cd4223ffd6 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -862,7 +862,7 @@ rt_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit, void *dd)
if ( !is_idle_vcpu(vc) )
svc->budget = RTDS_DEFAULT_BUDGET;
- SCHED_STAT_CRANK(vcpu_alloc);
+ SCHED_STAT_CRANK(unit_alloc);
return svc;
}
@@ -911,7 +911,7 @@ rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
}
unit_schedule_unlock_irq(lock, unit);
- SCHED_STAT_CRANK(vcpu_insert);
+ SCHED_STAT_CRANK(unit_insert);
}
/*
@@ -924,7 +924,7 @@ rt_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
struct rt_dom * const sdom = svc->sdom;
spinlock_t *lock;
- SCHED_STAT_CRANK(vcpu_remove);
+ SCHED_STAT_CRANK(unit_remove);
BUG_ON( sdom == NULL );
@@ -1146,7 +1146,7 @@ rt_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
struct rt_unit * const svc = rt_unit(unit);
BUG_ON( is_idle_vcpu(vc) );
- SCHED_STAT_CRANK(vcpu_sleep);
+ SCHED_STAT_CRANK(unit_sleep);
if ( curr_on_cpu(vc->processor) == unit )
cpu_raise_softirq(vc->processor, SCHEDULE_SOFTIRQ);
@@ -1267,21 +1267,21 @@ rt_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
if ( unlikely(curr_on_cpu(vc->processor) == unit) )
{
- SCHED_STAT_CRANK(vcpu_wake_running);
+ SCHED_STAT_CRANK(unit_wake_running);
return;
}
/* on RunQ/DepletedQ, just update info is ok */
if ( unlikely(vcpu_on_q(svc)) )
{
- SCHED_STAT_CRANK(vcpu_wake_onrunq);
+ SCHED_STAT_CRANK(unit_wake_onrunq);
return;
}
if ( likely(vcpu_runnable(vc)) )
- SCHED_STAT_CRANK(vcpu_wake_runnable);
+ SCHED_STAT_CRANK(unit_wake_runnable);
else
- SCHED_STAT_CRANK(vcpu_wake_not_runnable);
+ SCHED_STAT_CRANK(unit_wake_not_runnable);
/*
* If a deadline passed while svc was asleep/blocked, we need new
diff --git a/xen/include/xen/perfc_defn.h b/xen/include/xen/perfc_defn.h
index 1ad4384080..08b182ccd9 100644
--- a/xen/include/xen/perfc_defn.h
+++ b/xen/include/xen/perfc_defn.h
@@ -21,20 +21,20 @@ PERFCOUNTER(sched_ctx, "sched: context switches")
PERFCOUNTER(schedule, "sched: specific scheduler")
PERFCOUNTER(dom_init, "sched: dom_init")
PERFCOUNTER(dom_destroy, "sched: dom_destroy")
-PERFCOUNTER(vcpu_alloc, "sched: vcpu_alloc")
-PERFCOUNTER(vcpu_insert, "sched: vcpu_insert")
-PERFCOUNTER(vcpu_remove, "sched: vcpu_remove")
-PERFCOUNTER(vcpu_sleep, "sched: vcpu_sleep")
PERFCOUNTER(vcpu_yield, "sched: vcpu_yield")
-PERFCOUNTER(vcpu_wake_running, "sched: vcpu_wake_running")
-PERFCOUNTER(vcpu_wake_onrunq, "sched: vcpu_wake_onrunq")
-PERFCOUNTER(vcpu_wake_runnable, "sched: vcpu_wake_runnable")
-PERFCOUNTER(vcpu_wake_not_runnable, "sched: vcpu_wake_not_runnable")
+PERFCOUNTER(unit_alloc, "sched: unit_alloc")
+PERFCOUNTER(unit_insert, "sched: unit_insert")
+PERFCOUNTER(unit_remove, "sched: unit_remove")
+PERFCOUNTER(unit_sleep, "sched: unit_sleep")
+PERFCOUNTER(unit_wake_running, "sched: unit_wake_running")
+PERFCOUNTER(unit_wake_onrunq, "sched: unit_wake_onrunq")
+PERFCOUNTER(unit_wake_runnable, "sched: unit_wake_runnable")
+PERFCOUNTER(unit_wake_not_runnable, "sched: unit_wake_not_runnable")
PERFCOUNTER(tickled_no_cpu, "sched: tickled_no_cpu")
PERFCOUNTER(tickled_idle_cpu, "sched: tickled_idle_cpu")
PERFCOUNTER(tickled_idle_cpu_excl, "sched: tickled_idle_cpu_exclusive")
PERFCOUNTER(tickled_busy_cpu, "sched: tickled_busy_cpu")
-PERFCOUNTER(vcpu_check, "sched: vcpu_check")
+PERFCOUNTER(unit_check, "sched: unit_check")
/* credit specific counters */
PERFCOUNTER(delay_ms, "csched: delay")
@@ -43,11 +43,11 @@ PERFCOUNTER(acct_no_work, "csched: acct_no_work")
PERFCOUNTER(acct_balance, "csched: acct_balance")
PERFCOUNTER(acct_reorder, "csched: acct_reorder")
PERFCOUNTER(acct_min_credit, "csched: acct_min_credit")
-PERFCOUNTER(acct_vcpu_active, "csched: acct_vcpu_active")
-PERFCOUNTER(acct_vcpu_idle, "csched: acct_vcpu_idle")
-PERFCOUNTER(vcpu_boost, "csched: vcpu_boost")
-PERFCOUNTER(vcpu_park, "csched: vcpu_park")
-PERFCOUNTER(vcpu_unpark, "csched: vcpu_unpark")
+PERFCOUNTER(acct_unit_active, "csched: acct_unit_active")
+PERFCOUNTER(acct_unit_idle, "csched: acct_unit_idle")
+PERFCOUNTER(unit_boost, "csched: unit_boost")
+PERFCOUNTER(unit_park, "csched: unit_park")
+PERFCOUNTER(unit_unpark, "csched: unit_unpark")
PERFCOUNTER(load_balance_idle, "csched: load_balance_idle")
PERFCOUNTER(load_balance_over, "csched: load_balance_over")
PERFCOUNTER(load_balance_other, "csched: load_balance_other")
@@ -57,7 +57,7 @@ PERFCOUNTER(steal_peer_idle, "csched: steal_peer_idle")
PERFCOUNTER(migrate_queued, "csched: migrate_queued")
PERFCOUNTER(migrate_running, "csched: migrate_running")
PERFCOUNTER(migrate_kicked_away, "csched: migrate_kicked_away")
-PERFCOUNTER(vcpu_hot, "csched: vcpu_hot")
+PERFCOUNTER(unit_hot, "csched: unit_hot")
/* credit2 specific counters */
PERFCOUNTER(burn_credits_t2c, "csched2: burn_credits_t2c")
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 12/47] xen/sched: switch struct task_slice from vcpu to sched_unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (10 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 11/47] xen/sched: rename scheduler related perf counters Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-25 15:23 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit Juergen Gross
` (36 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Robert VanVossen, Dario Faggioli, Julien Grall, Josh Whitehead,
Meng Xu, Jan Beulich
Let the schedulers put a sched_unit pointer into struct task_slice
instead of a vcpu pointer.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/sched_arinc653.c | 8 ++++----
xen/common/sched_credit.c | 4 ++--
xen/common/sched_credit2.c | 4 ++--
xen/common/sched_null.c | 12 ++++++------
xen/common/sched_rt.c | 2 +-
xen/common/schedule.c | 4 ++--
xen/include/xen/sched-if.h | 6 +++---
7 files changed, 20 insertions(+), 20 deletions(-)
diff --git a/xen/common/sched_arinc653.c b/xen/common/sched_arinc653.c
index 98cdd7f894..6ae5924980 100644
--- a/xen/common/sched_arinc653.c
+++ b/xen/common/sched_arinc653.c
@@ -554,9 +554,9 @@ a653sched_do_schedule(
/*
* If there are more domains to run in the current major frame, set
- * new_task equal to the address of next domain's VCPU structure.
- * Otherwise, set new_task equal to the address of the idle task's VCPU
- * structure.
+ * new_task equal to the address of next domain's sched_unit structure.
+ * Otherwise, set new_task equal to the address of the idle task's
+ * sched_unit structure.
*/
new_task = (sched_index < sched_priv->num_schedule_entries)
? sched_priv->schedule[sched_index].vc
@@ -592,7 +592,7 @@ a653sched_do_schedule(
* of the selected task's VCPU structure.
*/
ret.time = next_switch_time - now;
- ret.task = new_task;
+ ret.task = new_task->sched_unit;
ret.migrated = 0;
BUG_ON(ret.time <= 0);
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index e430c4efa4..2bf11b0616 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -1993,9 +1993,9 @@ out:
*/
ret.time = (is_idle_vcpu(snext->vcpu) ?
-1 : tslice);
- ret.task = snext->vcpu;
+ ret.task = snext->vcpu->sched_unit;
- CSCHED_VCPU_CHECK(ret.task);
+ CSCHED_VCPU_CHECK(ret.task->vcpu_list);
return ret;
}
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index d82b7a9c75..910440d5d9 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -3637,9 +3637,9 @@ csched2_schedule(
* Return task to run next...
*/
ret.time = csched2_runtime(ops, cpu, snext, now);
- ret.task = snext->vcpu;
+ ret.task = snext->vcpu->sched_unit;
- CSCHED2_VCPU_CHECK(ret.task);
+ CSCHED2_VCPU_CHECK(ret.task->vcpu_list);
return ret;
}
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index 66f8387f11..63ee1f5439 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -819,10 +819,10 @@ static struct task_slice null_schedule(const struct scheduler *ops,
if ( tasklet_work_scheduled )
{
trace_var(TRC_SNULL_TASKLET, 1, 0, NULL);
- ret.task = idle_vcpu[cpu];
+ ret.task = idle_vcpu[cpu]->sched_unit;
}
else
- ret.task = per_cpu(npc, cpu).vcpu;
+ ret.task = per_cpu(npc, cpu).vcpu->sched_unit;
ret.migrated = 0;
ret.time = -1;
@@ -857,7 +857,7 @@ static struct task_slice null_schedule(const struct scheduler *ops,
{
vcpu_assign(prv, wvc->vcpu, cpu);
list_del_init(&wvc->waitq_elem);
- ret.task = wvc->vcpu;
+ ret.task = wvc->vcpu->sched_unit;
goto unlock;
}
}
@@ -869,10 +869,10 @@ static struct task_slice null_schedule(const struct scheduler *ops,
cpumask_set_cpu(cpu, &prv->cpus_free);
}
- if ( unlikely(ret.task == NULL || !vcpu_runnable(ret.task)) )
- ret.task = idle_vcpu[cpu];
+ if ( unlikely(ret.task == NULL || !unit_runnable(ret.task)) )
+ ret.task = idle_vcpu[cpu]->sched_unit;
- NULL_VCPU_CHECK(ret.task);
+ NULL_VCPU_CHECK(ret.task->vcpu_list);
return ret;
}
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index cd4223ffd6..8b5ae159b2 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -1130,7 +1130,7 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
}
ret.time = snext->cur_budget; /* invoke the scheduler next time */
}
- ret.task = snext->vcpu;
+ ret.task = snext->vcpu->sched_unit;
return ret;
}
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 152b76ccd6..92a74b731b 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -115,7 +115,7 @@ static struct task_slice sched_idle_schedule(
const unsigned int cpu = smp_processor_id();
struct task_slice ret = { .time = -1 };
- ret.task = idle_vcpu[cpu];
+ ret.task = sched_idle_unit(cpu);
return ret;
}
@@ -1626,7 +1626,7 @@ static void schedule(void)
sched = this_cpu(scheduler);
next_slice = sched->do_schedule(sched, now, tasklet_work_scheduled);
- next = next_slice.task;
+ next = next_slice.task->vcpu_list;
sd->curr = next->sched_unit;
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index fa3ca51a90..d624b81e53 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -192,9 +192,9 @@ static inline spinlock_t *pcpu_schedule_trylock(unsigned int cpu)
}
struct task_slice {
- struct vcpu *task;
- s_time_t time;
- bool_t migrated;
+ struct sched_unit *task;
+ s_time_t time;
+ bool_t migrated;
};
struct scheduler {
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (11 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 12/47] xen/sched: switch struct task_slice from vcpu to sched_unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-19 15:53 ` Jan Beulich
2019-09-25 15:27 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 14/47] xen/sched: make null scheduler vcpu agnostic Juergen Gross
` (35 subsequent siblings)
48 siblings, 2 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Meng Xu, Jan Beulich
Add an is_running indicator to struct sched_unit which will be set
whenever the unit is being scheduled. Switch scheduler code to use
unit->is_running instead of vcpu->is_running for scheduling decisions.
At the same time introduce a state_entry_time field in struct
sched_unit being updated whenever the is_running indicator is changed.
Use that new field in the schedulers instead of the similar vcpu field.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
RFC V2:
- fix arm build, don't drop v->is_running
V3:
- avoid holes in structures (Jan Beulich)
---
xen/common/sched_credit.c | 12 +++++++-----
xen/common/sched_credit2.c | 18 +++++++++---------
xen/common/sched_rt.c | 2 +-
xen/common/schedule.c | 13 ++++++++++---
xen/include/xen/sched.h | 6 ++++++
5 files changed, 33 insertions(+), 18 deletions(-)
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index 2bf11b0616..c0f6ef831e 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -709,7 +709,7 @@ __csched_vcpu_is_migrateable(const struct csched_private *prv, struct vcpu *vc,
* The caller is supposed to have already checked that vc is also
* not running.
*/
- ASSERT(!vc->is_running);
+ ASSERT(!vc->sched_unit->is_running);
return !__csched_vcpu_is_cache_hot(prv, svc) &&
cpumask_test_cpu(dest_cpu, mask);
@@ -1033,7 +1033,8 @@ csched_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
lock = unit_schedule_lock_irq(unit);
- if ( !__vcpu_on_runq(svc) && vcpu_runnable(vc) && !vc->is_running )
+ if ( !__vcpu_on_runq(svc) && vcpu_runnable(vc) &&
+ !vc->sched_unit->is_running )
runq_insert(svc);
unit_schedule_unlock_irq(lock, unit);
@@ -1646,8 +1647,9 @@ csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
* vCPUs with useful soft affinities in some sort of bitmap
* or counter.
*/
- if ( vc->is_running || (balance_step == BALANCE_SOFT_AFFINITY &&
- !has_soft_affinity(vc->sched_unit)) )
+ if ( vc->sched_unit->is_running ||
+ (balance_step == BALANCE_SOFT_AFFINITY &&
+ !has_soft_affinity(vc->sched_unit)) )
continue;
affinity_balance_cpumask(vc->sched_unit, balance_step, cpumask_scratch);
@@ -1855,7 +1857,7 @@ csched_schedule(
(unsigned char *)&d);
}
- runtime = now - current->runstate.state_entry_time;
+ runtime = now - current->sched_unit->state_entry_time;
if ( runtime < 0 ) /* Does this ever happen? */
runtime = 0;
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 910440d5d9..a6083289f6 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -1284,7 +1284,7 @@ runq_insert(const struct scheduler *ops, struct csched2_unit *svc)
ASSERT(&svc->rqd->runq == runq);
ASSERT(!is_idle_vcpu(svc->vcpu));
- ASSERT(!svc->vcpu->is_running);
+ ASSERT(!svc->vcpu->sched_unit->is_running);
ASSERT(!(svc->flags & CSFLAG_scheduled));
list_for_each( iter, runq )
@@ -1341,8 +1341,8 @@ static inline bool is_preemptable(const struct csched2_unit *svc,
if ( ratelimit <= CSCHED2_RATELIMIT_TICKLE_TOLERANCE )
return true;
- ASSERT(svc->vcpu->is_running);
- return now - svc->vcpu->runstate.state_entry_time >
+ ASSERT(svc->vcpu->sched_unit->is_running);
+ return now - svc->vcpu->sched_unit->state_entry_time >
ratelimit - CSCHED2_RATELIMIT_TICKLE_TOLERANCE;
}
@@ -2932,7 +2932,7 @@ csched2_dom_cntl(
{
svc = csched2_unit(v->sched_unit);
lock = unit_schedule_lock(svc->vcpu->sched_unit);
- if ( v->is_running )
+ if ( v->sched_unit->is_running )
{
unsigned int cpu = v->processor;
struct csched2_runqueue_data *rqd = c2rqd(ops, cpu);
@@ -3205,8 +3205,8 @@ csched2_runtime(const struct scheduler *ops, int cpu,
if ( prv->ratelimit_us )
{
s_time_t ratelimit_min = MICROSECS(prv->ratelimit_us);
- if ( snext->vcpu->is_running )
- ratelimit_min = snext->vcpu->runstate.state_entry_time +
+ if ( snext->vcpu->sched_unit->is_running )
+ ratelimit_min = snext->vcpu->sched_unit->state_entry_time +
MICROSECS(prv->ratelimit_us) - now;
if ( ratelimit_min > min_time )
min_time = ratelimit_min;
@@ -3303,7 +3303,7 @@ runq_candidate(struct csched2_runqueue_data *rqd,
* no point forcing it to do so until rate limiting expires.
*/
if ( !yield && prv->ratelimit_us && vcpu_runnable(scurr->vcpu) &&
- (now - scurr->vcpu->runstate.state_entry_time) <
+ (now - scurr->vcpu->sched_unit->state_entry_time) <
MICROSECS(prv->ratelimit_us) )
{
if ( unlikely(tb_init_done) )
@@ -3314,7 +3314,7 @@ runq_candidate(struct csched2_runqueue_data *rqd,
} d;
d.dom = scurr->vcpu->domain->domain_id;
d.vcpu = scurr->vcpu->vcpu_id;
- d.runtime = now - scurr->vcpu->runstate.state_entry_time;
+ d.runtime = now - scurr->vcpu->sched_unit->state_entry_time;
__trace_var(TRC_CSCHED2_RATELIMIT, 1,
sizeof(d),
(unsigned char *)&d);
@@ -3562,7 +3562,7 @@ csched2_schedule(
if ( snext != scurr )
{
ASSERT(snext->rqd == rqd);
- ASSERT(!snext->vcpu->is_running);
+ ASSERT(!snext->vcpu->sched_unit->is_running);
runq_remove(snext);
__set_bit(__CSFLAG_scheduled, &snext->flags);
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index 8b5ae159b2..a47cc598a9 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -906,7 +906,7 @@ rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
replq_insert(ops, svc);
- if ( !vc->is_running )
+ if ( !unit->is_running )
runq_insert(ops, svc);
}
unit_schedule_unlock_irq(lock, unit);
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 92a74b731b..05bc42d7e9 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -411,6 +411,8 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
{
get_sched_res(v->processor)->curr = unit;
v->is_running = 1;
+ unit->is_running = 1;
+ unit->state_entry_time = NOW();
}
else
{
@@ -731,7 +733,8 @@ static void vcpu_migrate_finish(struct vcpu *v)
* context_saved(); and in any case, if the bit is cleared, then
* someone else has already done the work so we don't need to.
*/
- if ( v->is_running || !test_bit(_VPF_migrating, &v->pause_flags) )
+ if ( v->sched_unit->is_running ||
+ !test_bit(_VPF_migrating, &v->pause_flags) )
return;
old_cpu = new_cpu = v->processor;
@@ -785,7 +788,7 @@ static void vcpu_migrate_finish(struct vcpu *v)
* because they both happen in (different) spinlock regions, and those
* regions are strictly serialised.
*/
- if ( v->is_running ||
+ if ( v->sched_unit->is_running ||
!test_and_clear_bit(_VPF_migrating, &v->pause_flags) )
{
sched_spin_unlock_double(old_lock, new_lock, flags);
@@ -1673,8 +1676,10 @@ static void schedule(void)
* switch, else lost_records resume will not work properly.
*/
- ASSERT(!next->is_running);
+ ASSERT(!next->sched_unit->is_running);
next->is_running = 1;
+ next->sched_unit->is_running = 1;
+ next->sched_unit->state_entry_time = now;
pcpu_schedule_unlock_irq(lock, cpu);
@@ -1696,6 +1701,8 @@ void context_saved(struct vcpu *prev)
smp_wmb();
prev->is_running = 0;
+ prev->sched_unit->is_running = 0;
+ prev->sched_unit->state_entry_time = NOW();
/* Check for migration request /after/ clearing running flag. */
smp_mb();
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 949bb6b696..d4698b3f0d 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -270,8 +270,14 @@ struct sched_unit {
struct sched_resource *res;
unsigned int unit_id;
+ /* Currently running on a CPU? */
+ bool is_running;
/* Does soft affinity actually play a role (given hard affinity)? */
bool soft_aff_effective;
+
+ /* Last time unit got (de-)scheduled. */
+ uint64_t state_entry_time;
+
/* Bitmask of CPUs on which this VCPU may run. */
cpumask_var_t cpu_hard_affinity;
/* Used to save affinity during temporary pinning. */
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 14/47] xen/sched: make null scheduler vcpu agnostic.
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (12 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-25 12:51 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 15/47] xen/sched: make rt " Juergen Gross
` (34 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Dario Faggioli
Switch null scheduler completely from vcpu to sched_unit usage.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/sched_null.c | 333 ++++++++++++++++++++++++------------------------
1 file changed, 165 insertions(+), 168 deletions(-)
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index 63ee1f5439..c3666c9f56 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -18,10 +18,10 @@
/*
* The 'null' scheduler always choose to run, on each pCPU, either nothing
- * (i.e., the pCPU stays idle) or always the same vCPU.
+ * (i.e., the pCPU stays idle) or always the same Item.
*
* It is aimed at supporting static scenarios, where there always are
- * less vCPUs than pCPUs (and the vCPUs don't need to move among pCPUs
+ * less Items than pCPUs (and the Items don't need to move among pCPUs
* for any reason) with the least possible overhead.
*
* Typical usecase are embedded applications, but also HPC, especially
@@ -37,8 +37,8 @@
* null tracing events. Check include/public/trace.h for more details.
*/
#define TRC_SNULL_PICKED_CPU TRC_SCHED_CLASS_EVT(SNULL, 1)
-#define TRC_SNULL_VCPU_ASSIGN TRC_SCHED_CLASS_EVT(SNULL, 2)
-#define TRC_SNULL_VCPU_DEASSIGN TRC_SCHED_CLASS_EVT(SNULL, 3)
+#define TRC_SNULL_UNIT_ASSIGN TRC_SCHED_CLASS_EVT(SNULL, 2)
+#define TRC_SNULL_UNIT_DEASSIGN TRC_SCHED_CLASS_EVT(SNULL, 3)
#define TRC_SNULL_MIGRATE TRC_SCHED_CLASS_EVT(SNULL, 4)
#define TRC_SNULL_SCHEDULE TRC_SCHED_CLASS_EVT(SNULL, 5)
#define TRC_SNULL_TASKLET TRC_SCHED_CLASS_EVT(SNULL, 6)
@@ -47,13 +47,13 @@
* Locking:
* - Scheduler-lock (a.k.a. runqueue lock):
* + is per-pCPU;
- * + serializes assignment and deassignment of vCPUs to a pCPU.
+ * + serializes assignment and deassignment of Items to a pCPU.
* - Private data lock (a.k.a. private scheduler lock):
* + is scheduler-wide;
* + serializes accesses to the list of domains in this scheduler.
* - Waitqueue lock:
* + is scheduler-wide;
- * + serialize accesses to the list of vCPUs waiting to be assigned
+ * + serialize accesses to the list of Items waiting to be assigned
* to pCPUs.
*
* Ordering is: private lock, runqueue lock, waitqueue lock. Or, OTOH,
@@ -77,25 +77,25 @@
struct null_private {
spinlock_t lock; /* scheduler lock; nests inside cpupool_lock */
struct list_head ndom; /* Domains of this scheduler */
- struct list_head waitq; /* vCPUs not assigned to any pCPU */
+ struct list_head waitq; /* Items not assigned to any pCPU */
spinlock_t waitq_lock; /* serializes waitq; nests inside runq locks */
- cpumask_t cpus_free; /* CPUs without a vCPU associated to them */
+ cpumask_t cpus_free; /* CPUs without a Item associated to them */
};
/*
* Physical CPU
*/
struct null_pcpu {
- struct vcpu *vcpu;
+ struct sched_unit *unit;
};
DEFINE_PER_CPU(struct null_pcpu, npc);
/*
- * Virtual CPU
+ * Schedule Item
*/
struct null_unit {
struct list_head waitq_elem;
- struct vcpu *vcpu;
+ struct sched_unit *unit;
};
/*
@@ -119,13 +119,13 @@ static inline struct null_unit *null_unit(const struct sched_unit *unit)
return unit->priv;
}
-static inline bool vcpu_check_affinity(struct vcpu *v, unsigned int cpu,
+static inline bool unit_check_affinity(struct sched_unit *unit,
+ unsigned int cpu,
unsigned int balance_step)
{
- affinity_balance_cpumask(v->sched_unit, balance_step,
- cpumask_scratch_cpu(cpu));
+ affinity_balance_cpumask(unit, balance_step, cpumask_scratch_cpu(cpu));
cpumask_and(cpumask_scratch_cpu(cpu), cpumask_scratch_cpu(cpu),
- cpupool_domain_cpumask(v->domain));
+ cpupool_domain_cpumask(unit->domain));
return cpumask_test_cpu(cpu, cpumask_scratch_cpu(cpu));
}
@@ -160,9 +160,9 @@ static void null_deinit(struct scheduler *ops)
static void init_pdata(struct null_private *prv, unsigned int cpu)
{
- /* Mark the pCPU as free, and with no vCPU assigned */
+ /* Mark the pCPU as free, and with no unit assigned */
cpumask_set_cpu(cpu, &prv->cpus_free);
- per_cpu(npc, cpu).vcpu = NULL;
+ per_cpu(npc, cpu).unit = NULL;
}
static void null_init_pdata(const struct scheduler *ops, void *pdata, int cpu)
@@ -183,13 +183,12 @@ static void null_deinit_pdata(const struct scheduler *ops, void *pcpu, int cpu)
ASSERT(!pcpu);
cpumask_clear_cpu(cpu, &prv->cpus_free);
- per_cpu(npc, cpu).vcpu = NULL;
+ per_cpu(npc, cpu).unit = NULL;
}
static void *null_alloc_vdata(const struct scheduler *ops,
struct sched_unit *unit, void *dd)
{
- struct vcpu *v = unit->vcpu_list;
struct null_unit *nvc;
nvc = xzalloc(struct null_unit);
@@ -197,7 +196,7 @@ static void *null_alloc_vdata(const struct scheduler *ops,
return NULL;
INIT_LIST_HEAD(&nvc->waitq_elem);
- nvc->vcpu = v;
+ nvc->unit = unit;
SCHED_STAT_CRANK(unit_alloc);
@@ -249,15 +248,15 @@ static void null_free_domdata(const struct scheduler *ops, void *data)
}
/*
- * vCPU to pCPU assignment and placement. This _only_ happens:
+ * unit to pCPU assignment and placement. This _only_ happens:
* - on insert,
* - on migrate.
*
- * Insert occurs when a vCPU joins this scheduler for the first time
+ * Insert occurs when a unit joins this scheduler for the first time
* (e.g., when the domain it's part of is moved to the scheduler's
* cpupool).
*
- * Migration may be necessary if a pCPU (with a vCPU assigned to it)
+ * Migration may be necessary if a pCPU (with a unit assigned to it)
* is removed from the scheduler's cpupool.
*
* So this is not part of any hot path.
@@ -266,9 +265,8 @@ static struct sched_resource *
pick_res(struct null_private *prv, const struct sched_unit *unit)
{
unsigned int bs;
- struct vcpu *v = unit->vcpu_list;
- unsigned int cpu = v->processor, new_cpu;
- cpumask_t *cpus = cpupool_domain_cpumask(v->domain);
+ unsigned int cpu = sched_unit_cpu(unit), new_cpu;
+ cpumask_t *cpus = cpupool_domain_cpumask(unit->domain);
ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
@@ -283,11 +281,12 @@ pick_res(struct null_private *prv, const struct sched_unit *unit)
/*
* If our processor is free, or we are assigned to it, and it is also
* still valid and part of our affinity, just go for it.
- * (Note that we may call vcpu_check_affinity(), but we deliberately
+ * (Note that we may call unit_check_affinity(), but we deliberately
* don't, so we get to keep in the scratch cpumask what we have just
* put in it.)
*/
- if ( likely((per_cpu(npc, cpu).vcpu == NULL || per_cpu(npc, cpu).vcpu == v)
+ if ( likely((per_cpu(npc, cpu).unit == NULL ||
+ per_cpu(npc, cpu).unit == unit)
&& cpumask_test_cpu(cpu, cpumask_scratch_cpu(cpu))) )
{
new_cpu = cpu;
@@ -305,13 +304,13 @@ pick_res(struct null_private *prv, const struct sched_unit *unit)
/*
* If we didn't find any free pCPU, just pick any valid pcpu, even if
- * it has another vCPU assigned. This will happen during shutdown and
+ * it has another Item assigned. This will happen during shutdown and
* suspend/resume, but it may also happen during "normal operation", if
* all the pCPUs are busy.
*
* In fact, there must always be something sane in v->processor, or
* unit_schedule_lock() and friends won't work. This is not a problem,
- * as we will actually assign the vCPU to the pCPU we return from here,
+ * as we will actually assign the Item to the pCPU we return from here,
* only if the pCPU is free.
*/
cpumask_and(cpumask_scratch_cpu(cpu), cpus, unit->cpu_hard_affinity);
@@ -321,11 +320,11 @@ pick_res(struct null_private *prv, const struct sched_unit *unit)
if ( unlikely(tb_init_done) )
{
struct {
- uint16_t vcpu, dom;
+ uint16_t unit, dom;
uint32_t new_cpu;
} d;
- d.dom = v->domain->domain_id;
- d.vcpu = v->vcpu_id;
+ d.dom = unit->domain->domain_id;
+ d.unit = unit->unit_id;
d.new_cpu = new_cpu;
__trace_var(TRC_SNULL_PICKED_CPU, 1, sizeof(d), &d);
}
@@ -333,64 +332,64 @@ pick_res(struct null_private *prv, const struct sched_unit *unit)
return get_sched_res(new_cpu);
}
-static void vcpu_assign(struct null_private *prv, struct vcpu *v,
+static void unit_assign(struct null_private *prv, struct sched_unit *unit,
unsigned int cpu)
{
- ASSERT(is_vcpu_online(v));
+ ASSERT(is_unit_online(unit));
- per_cpu(npc, cpu).vcpu = v;
- v->processor = cpu;
- v->sched_unit->res = get_sched_res(cpu);
+ per_cpu(npc, cpu).unit = unit;
+ sched_set_res(unit, get_sched_res(cpu));
cpumask_clear_cpu(cpu, &prv->cpus_free);
- dprintk(XENLOG_G_INFO, "%d <-- %pv\n", cpu, v);
+ dprintk(XENLOG_G_INFO, "%d <-- %pdv%d\n", cpu, unit->domain, unit->unit_id);
if ( unlikely(tb_init_done) )
{
struct {
- uint16_t vcpu, dom;
+ uint16_t unit, dom;
uint32_t cpu;
} d;
- d.dom = v->domain->domain_id;
- d.vcpu = v->vcpu_id;
+ d.dom = unit->domain->domain_id;
+ d.unit = unit->unit_id;
d.cpu = cpu;
- __trace_var(TRC_SNULL_VCPU_ASSIGN, 1, sizeof(d), &d);
+ __trace_var(TRC_SNULL_UNIT_ASSIGN, 1, sizeof(d), &d);
}
}
/* Returns true if a cpu was tickled */
-static bool vcpu_deassign(struct null_private *prv, struct vcpu *v)
+static bool unit_deassign(struct null_private *prv, struct sched_unit *unit)
{
unsigned int bs;
- unsigned int cpu = v->processor;
+ unsigned int cpu = sched_unit_cpu(unit);
struct null_unit *wvc;
- ASSERT(list_empty(&null_unit(v->sched_unit)->waitq_elem));
- ASSERT(per_cpu(npc, v->processor).vcpu == v);
- ASSERT(!cpumask_test_cpu(v->processor, &prv->cpus_free));
+ ASSERT(list_empty(&null_unit(unit)->waitq_elem));
+ ASSERT(per_cpu(npc, cpu).unit == unit);
+ ASSERT(!cpumask_test_cpu(cpu, &prv->cpus_free));
- per_cpu(npc, cpu).vcpu = NULL;
+ per_cpu(npc, cpu).unit = NULL;
cpumask_set_cpu(cpu, &prv->cpus_free);
- dprintk(XENLOG_G_INFO, "%d <-- NULL (%pv)\n", cpu, v);
+ dprintk(XENLOG_G_INFO, "%d <-- NULL (%pdv%d)\n", cpu, unit->domain,
+ unit->unit_id);
if ( unlikely(tb_init_done) )
{
struct {
- uint16_t vcpu, dom;
+ uint16_t unit, dom;
uint32_t cpu;
} d;
- d.dom = v->domain->domain_id;
- d.vcpu = v->vcpu_id;
+ d.dom = unit->domain->domain_id;
+ d.unit = unit->unit_id;
d.cpu = cpu;
- __trace_var(TRC_SNULL_VCPU_DEASSIGN, 1, sizeof(d), &d);
+ __trace_var(TRC_SNULL_UNIT_DEASSIGN, 1, sizeof(d), &d);
}
spin_lock(&prv->waitq_lock);
/*
- * If v is assigned to a pCPU, let's see if there is someone waiting,
- * suitable to be assigned to it (prioritizing vcpus that have
+ * If unit is assigned to a pCPU, let's see if there is someone waiting,
+ * suitable to be assigned to it (prioritizing units that have
* soft-affinity with cpu).
*/
for_each_affinity_balance_step( bs )
@@ -398,13 +397,13 @@ static bool vcpu_deassign(struct null_private *prv, struct vcpu *v)
list_for_each_entry( wvc, &prv->waitq, waitq_elem )
{
if ( bs == BALANCE_SOFT_AFFINITY &&
- !has_soft_affinity(wvc->vcpu->sched_unit) )
+ !has_soft_affinity(wvc->unit) )
continue;
- if ( vcpu_check_affinity(wvc->vcpu, cpu, bs) )
+ if ( unit_check_affinity(wvc->unit, cpu, bs) )
{
list_del_init(&wvc->waitq_elem);
- vcpu_assign(prv, wvc->vcpu, cpu);
+ unit_assign(prv, wvc->unit, cpu);
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
spin_unlock(&prv->waitq_lock);
return true;
@@ -425,9 +424,9 @@ static spinlock_t *null_switch_sched(struct scheduler *new_ops,
struct null_private *prv = null_priv(new_ops);
struct null_unit *nvc = vdata;
- ASSERT(nvc && is_idle_vcpu(nvc->vcpu));
+ ASSERT(nvc && is_idle_unit(nvc->unit));
- idle_vcpu[cpu]->sched_unit->priv = vdata;
+ sched_idle_unit(cpu)->priv = vdata;
/*
* We are holding the runqueue lock already (it's been taken in
@@ -444,41 +443,40 @@ static spinlock_t *null_switch_sched(struct scheduler *new_ops,
static void null_unit_insert(const struct scheduler *ops,
struct sched_unit *unit)
{
- struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
struct null_unit *nvc = null_unit(unit);
unsigned int cpu;
spinlock_t *lock;
- ASSERT(!is_idle_vcpu(v));
+ ASSERT(!is_idle_unit(unit));
lock = unit_schedule_lock_irq(unit);
- if ( unlikely(!is_vcpu_online(v)) )
+ if ( unlikely(!is_unit_online(unit)) )
{
unit_schedule_unlock_irq(lock, unit);
return;
}
retry:
- unit->res = pick_res(prv, unit);
- cpu = v->processor = unit->res->master_cpu;
+ sched_set_res(unit, pick_res(prv, unit));
+ cpu = sched_unit_cpu(unit);
spin_unlock(lock);
lock = unit_schedule_lock(unit);
cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
- cpupool_domain_cpumask(v->domain));
+ cpupool_domain_cpumask(unit->domain));
- /* If the pCPU is free, we assign v to it */
- if ( likely(per_cpu(npc, cpu).vcpu == NULL) )
+ /* If the pCPU is free, we assign unit to it */
+ if ( likely(per_cpu(npc, cpu).unit == NULL) )
{
/*
* Insert is followed by vcpu_wake(), so there's no need to poke
* the pcpu with the SCHEDULE_SOFTIRQ, as wake will do that.
*/
- vcpu_assign(prv, v, cpu);
+ unit_assign(prv, unit, cpu);
}
else if ( cpumask_intersects(&prv->cpus_free, cpumask_scratch_cpu(cpu)) )
{
@@ -497,7 +495,8 @@ static void null_unit_insert(const struct scheduler *ops,
*/
spin_lock(&prv->waitq_lock);
list_add_tail(&nvc->waitq_elem, &prv->waitq);
- dprintk(XENLOG_G_WARNING, "WARNING: %pv not assigned to any CPU!\n", v);
+ dprintk(XENLOG_G_WARNING, "WARNING: %pdv%d not assigned to any CPU!\n",
+ unit->domain, unit->unit_id);
spin_unlock(&prv->waitq_lock);
}
spin_unlock_irq(lock);
@@ -508,24 +507,23 @@ static void null_unit_insert(const struct scheduler *ops,
static void null_unit_remove(const struct scheduler *ops,
struct sched_unit *unit)
{
- struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
struct null_unit *nvc = null_unit(unit);
spinlock_t *lock;
- ASSERT(!is_idle_vcpu(v));
+ ASSERT(!is_idle_unit(unit));
lock = unit_schedule_lock_irq(unit);
- /* If offline, the vcpu shouldn't be assigned, nor in the waitqueue */
- if ( unlikely(!is_vcpu_online(v)) )
+ /* If offline, the unit shouldn't be assigned, nor in the waitqueue */
+ if ( unlikely(!is_unit_online(unit)) )
{
- ASSERT(per_cpu(npc, v->processor).vcpu != v);
+ ASSERT(per_cpu(npc, sched_unit_cpu(unit)).unit != unit);
ASSERT(list_empty(&nvc->waitq_elem));
goto out;
}
- /* If v is in waitqueue, just get it out of there and bail */
+ /* If unit is in waitqueue, just get it out of there and bail */
if ( unlikely(!list_empty(&nvc->waitq_elem)) )
{
spin_lock(&prv->waitq_lock);
@@ -535,7 +533,7 @@ static void null_unit_remove(const struct scheduler *ops,
goto out;
}
- vcpu_deassign(prv, v);
+ unit_deassign(prv, unit);
out:
unit_schedule_unlock_irq(lock, unit);
@@ -546,14 +544,13 @@ static void null_unit_remove(const struct scheduler *ops,
static void null_unit_wake(const struct scheduler *ops,
struct sched_unit *unit)
{
- struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
struct null_unit *nvc = null_unit(unit);
- unsigned int cpu = v->processor;
+ unsigned int cpu = sched_unit_cpu(unit);
- ASSERT(!is_idle_vcpu(v));
+ ASSERT(!is_idle_unit(unit));
- if ( unlikely(curr_on_cpu(cpu) == unit) )
+ if ( unlikely(curr_on_cpu(sched_unit_cpu(unit)) == unit) )
{
SCHED_STAT_CRANK(unit_wake_running);
return;
@@ -566,33 +563,33 @@ static void null_unit_wake(const struct scheduler *ops,
return;
}
- if ( likely(vcpu_runnable(v)) )
+ if ( likely(unit_runnable(unit)) )
SCHED_STAT_CRANK(unit_wake_runnable);
else
SCHED_STAT_CRANK(unit_wake_not_runnable);
/*
- * If a vcpu is neither on a pCPU nor in the waitqueue, it means it was
+ * If a unit is neither on a pCPU nor in the waitqueue, it means it was
* offline, and that it is now coming back being online.
*/
- if ( unlikely(per_cpu(npc, cpu).vcpu != v && list_empty(&nvc->waitq_elem)) )
+ if ( unlikely(per_cpu(npc, cpu).unit != unit && list_empty(&nvc->waitq_elem)) )
{
spin_lock(&prv->waitq_lock);
list_add_tail(&nvc->waitq_elem, &prv->waitq);
spin_unlock(&prv->waitq_lock);
cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
- cpupool_domain_cpumask(v->domain));
+ cpupool_domain_cpumask(unit->domain));
if ( !cpumask_intersects(&prv->cpus_free, cpumask_scratch_cpu(cpu)) )
{
dprintk(XENLOG_G_WARNING, "WARNING: d%dv%d not assigned to any CPU!\n",
- v->domain->domain_id, v->vcpu_id);
+ unit->domain->domain_id, unit->unit_id);
return;
}
/*
- * Now we would want to assign the vcpu to cpu, but we can't, because
+ * Now we would want to assign the unit to cpu, but we can't, because
* we don't have the lock. So, let's do the following:
* - try to remove cpu from the list of free cpus, to avoid races with
* other onlining, inserting or migrating operations;
@@ -613,25 +610,24 @@ static void null_unit_wake(const struct scheduler *ops,
}
}
- /* Note that we get here only for vCPUs assigned to a pCPU */
- cpu_raise_softirq(v->processor, SCHEDULE_SOFTIRQ);
+ /* Note that we get here only for units assigned to a pCPU */
+ cpu_raise_softirq(sched_unit_cpu(unit), SCHEDULE_SOFTIRQ);
}
static void null_unit_sleep(const struct scheduler *ops,
struct sched_unit *unit)
{
- struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
- unsigned int cpu = v->processor;
+ unsigned int cpu = sched_unit_cpu(unit);
bool tickled = false;
- ASSERT(!is_idle_vcpu(v));
+ ASSERT(!is_idle_unit(unit));
- /*
- * Check if the vcpu is in the process of being offlined. if yes,
+ /*
+ * Check if the unit is in the process of being offlined. If yes,
* we need to remove it from either its pCPU or the waitqueue.
*/
- if ( unlikely(!is_vcpu_online(v)) )
+ if ( unlikely(!is_unit_online(unit)) )
{
struct null_unit *nvc = null_unit(unit);
@@ -641,11 +637,11 @@ static void null_unit_sleep(const struct scheduler *ops,
list_del_init(&nvc->waitq_elem);
spin_unlock(&prv->waitq_lock);
}
- else if ( per_cpu(npc, cpu).vcpu == v )
- tickled = vcpu_deassign(prv, v);
+ else if ( per_cpu(npc, cpu).unit == unit )
+ tickled = unit_deassign(prv, unit);
}
- /* If v is not assigned to a pCPU, or is not running, no need to bother */
+ /* If unit is not assigned to a pCPU, or is not running, no need to bother */
if ( likely(!tickled && curr_on_cpu(cpu) == unit) )
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
@@ -655,42 +651,41 @@ static void null_unit_sleep(const struct scheduler *ops,
static struct sched_resource *
null_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
- ASSERT(!is_idle_vcpu(unit->vcpu_list));
+ ASSERT(!is_idle_unit(unit));
return pick_res(null_priv(ops), unit);
}
static void null_unit_migrate(const struct scheduler *ops,
struct sched_unit *unit, unsigned int new_cpu)
{
- struct vcpu *v = unit->vcpu_list;
struct null_private *prv = null_priv(ops);
struct null_unit *nvc = null_unit(unit);
- ASSERT(!is_idle_vcpu(v));
+ ASSERT(!is_idle_unit(unit));
- if ( v->processor == new_cpu )
+ if ( sched_unit_cpu(unit) == new_cpu )
return;
if ( unlikely(tb_init_done) )
{
struct {
- uint16_t vcpu, dom;
+ uint16_t unit, dom;
uint16_t cpu, new_cpu;
} d;
- d.dom = v->domain->domain_id;
- d.vcpu = v->vcpu_id;
- d.cpu = v->processor;
+ d.dom = unit->domain->domain_id;
+ d.unit = unit->unit_id;
+ d.cpu = sched_unit_cpu(unit);
d.new_cpu = new_cpu;
__trace_var(TRC_SNULL_MIGRATE, 1, sizeof(d), &d);
}
/*
- * If v is assigned to a pCPU, then such pCPU becomes free, and we
+ * If unit is assigned to a pCPU, then such pCPU becomes free, and we
* should look in the waitqueue if anyone else can be assigned to it.
*/
- if ( likely(per_cpu(npc, v->processor).vcpu == v) )
+ if ( likely(per_cpu(npc, sched_unit_cpu(unit)).unit == unit) )
{
- vcpu_deassign(prv, v);
+ unit_deassign(prv, unit);
SCHED_STAT_CRANK(migrate_running);
}
else if ( !list_empty(&nvc->waitq_elem) )
@@ -699,13 +694,13 @@ static void null_unit_migrate(const struct scheduler *ops,
SCHED_STAT_CRANK(migrated);
/*
- * If a vcpu is (going) offline, we want it to be neither assigned
+ * If a unit is (going) offline, we want it to be neither assigned
* to a pCPU, nor in the waitqueue.
*
* If it was on a cpu, we've removed it from there above. If it is
* in the waitqueue, we remove it from there now. And then we bail.
*/
- if ( unlikely(!is_vcpu_online(v)) )
+ if ( unlikely(!is_unit_online(unit)) )
{
spin_lock(&prv->waitq_lock);
list_del_init(&nvc->waitq_elem);
@@ -714,32 +709,34 @@ static void null_unit_migrate(const struct scheduler *ops,
}
/*
- * Let's now consider new_cpu, which is where v is being sent. It can be
- * either free, or have a vCPU already assigned to it.
+ * Let's now consider new_cpu, which is where unit is being sent. It can be
+ * either free, or have a unit already assigned to it.
*
- * In the former case, we should assign v to it, and try to get it to run,
+ * In the former case we should assign unit to it, and try to get it to run,
* if possible, according to affinity.
*
- * In latter, all we can do is to park v in the waitqueue.
+ * In latter, all we can do is to park unit in the waitqueue.
*/
- if ( per_cpu(npc, new_cpu).vcpu == NULL &&
- vcpu_check_affinity(v, new_cpu, BALANCE_HARD_AFFINITY) )
+ if ( per_cpu(npc, new_cpu).unit == NULL &&
+ unit_check_affinity(unit, new_cpu, BALANCE_HARD_AFFINITY) )
{
- /* v might have been in the waitqueue, so remove it */
+ /* unit might have been in the waitqueue, so remove it */
spin_lock(&prv->waitq_lock);
list_del_init(&nvc->waitq_elem);
spin_unlock(&prv->waitq_lock);
- vcpu_assign(prv, v, new_cpu);
+ unit_assign(prv, unit, new_cpu);
}
else
{
- /* Put v in the waitqueue, if it wasn't there already */
+ /* Put unit in the waitqueue, if it wasn't there already */
spin_lock(&prv->waitq_lock);
if ( list_empty(&nvc->waitq_elem) )
{
list_add_tail(&nvc->waitq_elem, &prv->waitq);
- dprintk(XENLOG_G_WARNING, "WARNING: %pv not assigned to any CPU!\n", v);
+ dprintk(XENLOG_G_WARNING,
+ "WARNING: %pdv%d not assigned to any CPU!\n", unit->domain,
+ unit->unit_id);
}
spin_unlock(&prv->waitq_lock);
}
@@ -753,35 +750,34 @@ static void null_unit_migrate(const struct scheduler *ops,
* by this, will be fixed-up during resume.
*/
out:
- v->processor = new_cpu;
- unit->res = get_sched_res(new_cpu);
+ sched_set_res(unit, get_sched_res(new_cpu));
}
#ifndef NDEBUG
-static inline void null_vcpu_check(struct vcpu *v)
+static inline void null_unit_check(struct sched_unit *unit)
{
- struct null_unit * const nvc = null_unit(v->sched_unit);
- struct null_dom * const ndom = v->domain->sched_priv;
+ struct null_unit * const nvc = null_unit(unit);
+ struct null_dom * const ndom = unit->domain->sched_priv;
- BUG_ON(nvc->vcpu != v);
+ BUG_ON(nvc->unit != unit);
if ( ndom )
- BUG_ON(is_idle_vcpu(v));
+ BUG_ON(is_idle_unit(unit));
else
- BUG_ON(!is_idle_vcpu(v));
+ BUG_ON(!is_idle_unit(unit));
SCHED_STAT_CRANK(unit_check);
}
-#define NULL_VCPU_CHECK(v) (null_vcpu_check(v))
+#define NULL_UNIT_CHECK(unit) (null_unit_check(unit))
#else
-#define NULL_VCPU_CHECK(v)
+#define NULL_UNIT_CHECK(unit)
#endif
/*
* The most simple scheduling function of all times! We either return:
- * - the vCPU assigned to the pCPU, if there's one and it can run;
- * - the idle vCPU, otherwise.
+ * - the unit assigned to the pCPU, if there's one and it can run;
+ * - the idle unit, otherwise.
*/
static struct task_slice null_schedule(const struct scheduler *ops,
s_time_t now,
@@ -794,24 +790,24 @@ static struct task_slice null_schedule(const struct scheduler *ops,
struct task_slice ret;
SCHED_STAT_CRANK(schedule);
- NULL_VCPU_CHECK(current);
+ NULL_UNIT_CHECK(current->sched_unit);
if ( unlikely(tb_init_done) )
{
struct {
uint16_t tasklet, cpu;
- int16_t vcpu, dom;
+ int16_t unit, dom;
} d;
d.cpu = cpu;
d.tasklet = tasklet_work_scheduled;
- if ( per_cpu(npc, cpu).vcpu == NULL )
+ if ( per_cpu(npc, cpu).unit == NULL )
{
- d.vcpu = d.dom = -1;
+ d.unit = d.dom = -1;
}
else
{
- d.vcpu = per_cpu(npc, cpu).vcpu->vcpu_id;
- d.dom = per_cpu(npc, cpu).vcpu->domain->domain_id;
+ d.unit = per_cpu(npc, cpu).unit->unit_id;
+ d.dom = per_cpu(npc, cpu).unit->domain->domain_id;
}
__trace_var(TRC_SNULL_SCHEDULE, 1, sizeof(d), &d);
}
@@ -819,16 +815,16 @@ static struct task_slice null_schedule(const struct scheduler *ops,
if ( tasklet_work_scheduled )
{
trace_var(TRC_SNULL_TASKLET, 1, 0, NULL);
- ret.task = idle_vcpu[cpu]->sched_unit;
+ ret.task = sched_idle_unit(cpu);
}
else
- ret.task = per_cpu(npc, cpu).vcpu->sched_unit;
+ ret.task = per_cpu(npc, cpu).unit;
ret.migrated = 0;
ret.time = -1;
/*
* We may be new in the cpupool, or just coming back online. In which
- * case, there may be vCPUs in the waitqueue that we can assign to us
+ * case, there may be units in the waitqueue that we can assign to us
* and run.
*/
if ( unlikely(ret.task == NULL) )
@@ -839,10 +835,10 @@ static struct task_slice null_schedule(const struct scheduler *ops,
goto unlock;
/*
- * We scan the waitqueue twice, for prioritizing vcpus that have
+ * We scan the waitqueue twice, for prioritizing units that have
* soft-affinity with cpu. This may look like something expensive to
- * do here in null_schedule(), but it's actually fine, beceuse we do
- * it only in cases where a pcpu has no vcpu associated (e.g., as
+ * do here in null_schedule(), but it's actually fine, because we do
+ * it only in cases where a pcpu has no unit associated (e.g., as
* said above, the cpu has just joined a cpupool).
*/
for_each_affinity_balance_step( bs )
@@ -850,14 +846,14 @@ static struct task_slice null_schedule(const struct scheduler *ops,
list_for_each_entry( wvc, &prv->waitq, waitq_elem )
{
if ( bs == BALANCE_SOFT_AFFINITY &&
- !has_soft_affinity(wvc->vcpu->sched_unit) )
+ !has_soft_affinity(wvc->unit) )
continue;
- if ( vcpu_check_affinity(wvc->vcpu, cpu, bs) )
+ if ( unit_check_affinity(wvc->unit, cpu, bs) )
{
- vcpu_assign(prv, wvc->vcpu, cpu);
+ unit_assign(prv, wvc->unit, cpu);
list_del_init(&wvc->waitq_elem);
- ret.task = wvc->vcpu->sched_unit;
+ ret.task = wvc->unit;
goto unlock;
}
}
@@ -870,17 +866,17 @@ static struct task_slice null_schedule(const struct scheduler *ops,
}
if ( unlikely(ret.task == NULL || !unit_runnable(ret.task)) )
- ret.task = idle_vcpu[cpu]->sched_unit;
+ ret.task = sched_idle_unit(cpu);
- NULL_VCPU_CHECK(ret.task->vcpu_list);
+ NULL_UNIT_CHECK(ret.task);
return ret;
}
-static inline void dump_vcpu(struct null_private *prv, struct null_unit *nvc)
+static inline void dump_unit(struct null_private *prv, struct null_unit *nvc)
{
- printk("[%i.%i] pcpu=%d", nvc->vcpu->domain->domain_id,
- nvc->vcpu->vcpu_id, list_empty(&nvc->waitq_elem) ?
- nvc->vcpu->processor : -1);
+ printk("[%i.%i] pcpu=%d", nvc->unit->domain->domain_id,
+ nvc->unit->unit_id, list_empty(&nvc->waitq_elem) ?
+ sched_unit_cpu(nvc->unit) : -1);
}
static void null_dump_pcpu(const struct scheduler *ops, int cpu)
@@ -895,16 +891,17 @@ static void null_dump_pcpu(const struct scheduler *ops, int cpu)
printk("CPU[%02d] sibling=%*pb, core=%*pb",
cpu, CPUMASK_PR(per_cpu(cpu_sibling_mask, cpu)),
CPUMASK_PR(per_cpu(cpu_core_mask, cpu)));
- if ( per_cpu(npc, cpu).vcpu != NULL )
- printk(", vcpu=%pv", per_cpu(npc, cpu).vcpu);
+ if ( per_cpu(npc, cpu).unit != NULL )
+ printk(", unit=%pdv%d", per_cpu(npc, cpu).unit->domain,
+ per_cpu(npc, cpu).unit->unit_id);
printk("\n");
- /* current VCPU (nothing to say if that's the idle vcpu) */
+ /* current unit (nothing to say if that's the idle unit) */
nvc = null_unit(curr_on_cpu(cpu));
- if ( nvc && !is_idle_vcpu(nvc->vcpu) )
+ if ( nvc && !is_idle_unit(nvc->unit) )
{
printk("\trun: ");
- dump_vcpu(prv, nvc);
+ dump_unit(prv, nvc);
printk("\n");
}
@@ -927,23 +924,23 @@ static void null_dump(const struct scheduler *ops)
list_for_each( iter, &prv->ndom )
{
struct null_dom *ndom;
- struct vcpu *v;
+ struct sched_unit *unit;
ndom = list_entry(iter, struct null_dom, ndom_elem);
printk("\tDomain: %d\n", ndom->dom->domain_id);
- for_each_vcpu( ndom->dom, v )
+ for_each_sched_unit( ndom->dom, unit )
{
- struct null_unit * const nvc = null_unit(v->sched_unit);
+ struct null_unit * const nvc = null_unit(unit);
spinlock_t *lock;
- lock = unit_schedule_lock(nvc->vcpu->sched_unit);
+ lock = unit_schedule_lock(unit);
printk("\t%3d: ", ++loop);
- dump_vcpu(prv, nvc);
+ dump_unit(prv, nvc);
printk("\n");
- unit_schedule_unlock(lock, nvc->vcpu->sched_unit);
+ unit_schedule_unlock(lock, unit);
}
}
@@ -958,7 +955,7 @@ static void null_dump(const struct scheduler *ops)
printk(", ");
if ( loop % 24 == 0 )
printk("\n\t");
- printk("%pv", nvc->vcpu);
+ printk("%pdv%d", nvc->unit->domain, nvc->unit->unit_id);
}
printk("\n");
spin_unlock(&prv->waitq_lock);
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 15/47] xen/sched: make rt scheduler vcpu agnostic.
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (13 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 14/47] xen/sched: make null scheduler vcpu agnostic Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-25 13:20 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 16/47] xen/sched: make credit " Juergen Gross
` (33 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Meng Xu, Dario Faggioli
Switch rt scheduler completely from vcpu to sched_unit usage.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/sched_rt.c | 356 ++++++++++++++++++++++++--------------------------
1 file changed, 174 insertions(+), 182 deletions(-)
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index a47cc598a9..7a72cfb86c 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -36,7 +36,7 @@
*
* Migration compensation and resist like credit2 to better use cache;
* Lock Holder Problem, using yield?
- * Self switch problem: VCPUs of the same domain may preempt each other;
+ * Self switch problem: UNITs of the same domain may preempt each other;
*/
/*
@@ -44,30 +44,30 @@
*
* This scheduler follows the Preemptive Global Earliest Deadline First (EDF)
* theory in real-time field.
- * At any scheduling point, the VCPU with earlier deadline has higher priority.
- * The scheduler always picks highest priority VCPU to run on a feasible PCPU.
- * A PCPU is feasible if the VCPU can run on this PCPU and (the PCPU is idle or
- * has a lower-priority VCPU running on it.)
+ * At any scheduling point, the UNIT with earlier deadline has higher priority.
+ * The scheduler always picks highest priority UNIT to run on a feasible PCPU.
+ * A PCPU is feasible if the UNIT can run on this PCPU and (the PCPU is idle or
+ * has a lower-priority UNIT running on it.)
*
- * Each VCPU has a dedicated period, budget and a extratime flag
- * The deadline of a VCPU is at the end of each period;
- * A VCPU has its budget replenished at the beginning of each period;
- * While scheduled, a VCPU burns its budget.
- * The VCPU needs to finish its budget before its deadline in each period;
- * The VCPU discards its unused budget at the end of each period.
- * When a VCPU runs out of budget in a period, if its extratime flag is set,
- * the VCPU increases its priority_level by 1 and refills its budget; otherwise,
+ * Each UNIT has a dedicated period, budget and a extratime flag
+ * The deadline of an UNIT is at the end of each period;
+ * An UNIT has its budget replenished at the beginning of each period;
+ * While scheduled, an UNIT burns its budget.
+ * The UNIT needs to finish its budget before its deadline in each period;
+ * The UNIT discards its unused budget at the end of each period.
+ * When an UNIT runs out of budget in a period, if its extratime flag is set,
+ * the UNIT increases its priority_level by 1 and refills its budget; otherwise,
* it has to wait until next period.
*
- * Each VCPU is implemented as a deferable server.
- * When a VCPU has a task running on it, its budget is continuously burned;
- * When a VCPU has no task but with budget left, its budget is preserved.
+ * Each UNIT is implemented as a deferable server.
+ * When an UNIT has a task running on it, its budget is continuously burned;
+ * When an UNIT has no task but with budget left, its budget is preserved.
*
* Queue scheme:
* A global runqueue and a global depletedqueue for each CPU pool.
- * The runqueue holds all runnable VCPUs with budget,
+ * The runqueue holds all runnable UNITs with budget,
* sorted by priority_level and deadline;
- * The depletedqueue holds all VCPUs without budget, unsorted;
+ * The depletedqueue holds all UNITs without budget, unsorted;
*
* Note: cpumask and cpupool is supported.
*/
@@ -82,7 +82,7 @@
* in schedule.c
*
* The functions involes RunQ and needs to grab locks are:
- * vcpu_insert, vcpu_remove, context_saved, runq_insert
+ * unit_insert, unit_remove, context_saved, runq_insert
*/
@@ -95,7 +95,7 @@
/*
* Max period: max delta of time type, because period is added to the time
- * a vcpu activates, so this must not overflow.
+ * an unit activates, so this must not overflow.
* Min period: 10 us, considering the scheduling overhead (when period is
* too low, scheduling is invoked too frequently, causing high overhead).
*/
@@ -121,12 +121,12 @@
* Flags
*/
/*
- * RTDS_scheduled: Is this vcpu either running on, or context-switching off,
+ * RTDS_scheduled: Is this unit either running on, or context-switching off,
* a phyiscal cpu?
* + Accessed only with global lock held.
* + Set when chosen as next in rt_schedule().
* + Cleared after context switch has been saved in rt_context_saved()
- * + Checked in vcpu_wake to see if we can add to the Runqueue, or if we should
+ * + Checked in unit_wake to see if we can add to the Runqueue, or if we should
* set RTDS_delayed_runq_add
* + Checked to be false in runq_insert.
*/
@@ -146,15 +146,15 @@
/*
* RTDS_depleted: Does this vcp run out of budget?
* This flag is
- * + set in burn_budget() if a vcpu has zero budget left;
+ * + set in burn_budget() if an unit has zero budget left;
* + cleared and checked in the repenishment handler,
- * for the vcpus that are being replenished.
+ * for the units that are being replenished.
*/
#define __RTDS_depleted 3
#define RTDS_depleted (1<<__RTDS_depleted)
/*
- * RTDS_extratime: Can the vcpu run in the time that is
+ * RTDS_extratime: Can the unit run in the time that is
* not part of any real-time reservation, and would therefore
* be otherwise left idle?
*/
@@ -183,11 +183,11 @@ struct rt_private {
spinlock_t lock; /* the global coarse-grained lock */
struct list_head sdom; /* list of availalbe domains, used for dump */
- struct list_head runq; /* ordered list of runnable vcpus */
- struct list_head depletedq; /* unordered list of depleted vcpus */
+ struct list_head runq; /* ordered list of runnable units */
+ struct list_head depletedq; /* unordered list of depleted units */
struct timer repl_timer; /* replenishment timer */
- struct list_head replq; /* ordered list of vcpus that need replenishment */
+ struct list_head replq; /* ordered list of units that need replenishment */
cpumask_t tickled; /* cpus been tickled */
};
@@ -199,18 +199,18 @@ struct rt_unit {
struct list_head q_elem; /* on the runq/depletedq list */
struct list_head replq_elem; /* on the replenishment events list */
- /* VCPU parameters, in nanoseconds */
+ /* UNIT parameters, in nanoseconds */
s_time_t period;
s_time_t budget;
- /* VCPU current information in nanosecond */
+ /* UNIT current information in nanosecond */
s_time_t cur_budget; /* current budget */
s_time_t last_start; /* last start time */
s_time_t cur_deadline; /* current deadline for EDF */
/* Up-pointers */
struct rt_dom *sdom;
- struct vcpu *vcpu;
+ struct sched_unit *unit;
unsigned priority_level;
@@ -263,7 +263,7 @@ static inline bool has_extratime(const struct rt_unit *svc)
* and the replenishment events queue.
*/
static int
-vcpu_on_q(const struct rt_unit *svc)
+unit_on_q(const struct rt_unit *svc)
{
return !list_empty(&svc->q_elem);
}
@@ -281,7 +281,7 @@ replq_elem(struct list_head *elem)
}
static int
-vcpu_on_replq(const struct rt_unit *svc)
+unit_on_replq(const struct rt_unit *svc)
{
return !list_empty(&svc->replq_elem);
}
@@ -291,7 +291,7 @@ vcpu_on_replq(const struct rt_unit *svc)
* Otherwise, return value < 0
*/
static s_time_t
-compare_vcpu_priority(const struct rt_unit *v1, const struct rt_unit *v2)
+compare_unit_priority(const struct rt_unit *v1, const struct rt_unit *v2)
{
int prio = v2->priority_level - v1->priority_level;
@@ -302,15 +302,15 @@ compare_vcpu_priority(const struct rt_unit *v1, const struct rt_unit *v2)
}
/*
- * Debug related code, dump vcpu/cpu information
+ * Debug related code, dump unit/cpu information
*/
static void
-rt_dump_vcpu(const struct scheduler *ops, const struct rt_unit *svc)
+rt_dump_unit(const struct scheduler *ops, const struct rt_unit *svc)
{
cpumask_t *cpupool_mask, *mask;
ASSERT(svc != NULL);
- /* idle vcpu */
+ /* idle unit */
if( svc->sdom == NULL )
{
printk("\n");
@@ -321,20 +321,20 @@ rt_dump_vcpu(const struct scheduler *ops, const struct rt_unit *svc)
* We can't just use 'cpumask_scratch' because the dumping can
* happen from a pCPU outside of this scheduler's cpupool, and
* hence it's not right to use its pCPU's scratch mask.
- * On the other hand, it is safe to use svc->vcpu->processor's
+ * On the other hand, it is safe to use sched_unit_cpu(svc->unit)'s
* own scratch space, since we hold the runqueue lock.
*/
- mask = cpumask_scratch_cpu(svc->vcpu->processor);
+ mask = cpumask_scratch_cpu(sched_unit_cpu(svc->unit));
- cpupool_mask = cpupool_domain_cpumask(svc->vcpu->domain);
- cpumask_and(mask, cpupool_mask, svc->vcpu->sched_unit->cpu_hard_affinity);
+ cpupool_mask = cpupool_domain_cpumask(svc->unit->domain);
+ cpumask_and(mask, cpupool_mask, svc->unit->cpu_hard_affinity);
printk("[%5d.%-2u] cpu %u, (%"PRI_stime", %"PRI_stime"),"
" cur_b=%"PRI_stime" cur_d=%"PRI_stime" last_start=%"PRI_stime"\n"
" \t\t priority_level=%d has_extratime=%d\n"
" \t\t onQ=%d runnable=%d flags=%x effective hard_affinity=%*pbl\n",
- svc->vcpu->domain->domain_id,
- svc->vcpu->vcpu_id,
- svc->vcpu->processor,
+ svc->unit->domain->domain_id,
+ svc->unit->unit_id,
+ sched_unit_cpu(svc->unit),
svc->period,
svc->budget,
svc->cur_budget,
@@ -342,8 +342,8 @@ rt_dump_vcpu(const struct scheduler *ops, const struct rt_unit *svc)
svc->last_start,
svc->priority_level,
has_extratime(svc),
- vcpu_on_q(svc),
- vcpu_runnable(svc->vcpu),
+ unit_on_q(svc),
+ unit_runnable(svc->unit),
svc->flags, CPUMASK_PR(mask));
}
@@ -356,11 +356,11 @@ rt_dump_pcpu(const struct scheduler *ops, int cpu)
spin_lock_irqsave(&prv->lock, flags);
printk("CPU[%02d]\n", cpu);
- /* current VCPU (nothing to say if that's the idle vcpu). */
+ /* current UNIT (nothing to say if that's the idle unit). */
svc = rt_unit(curr_on_cpu(cpu));
- if ( svc && !is_idle_vcpu(svc->vcpu) )
+ if ( svc && !is_idle_unit(svc->unit) )
{
- rt_dump_vcpu(ops, svc);
+ rt_dump_unit(ops, svc);
}
spin_unlock_irqrestore(&prv->lock, flags);
}
@@ -387,35 +387,35 @@ rt_dump(const struct scheduler *ops)
list_for_each ( iter, runq )
{
svc = q_elem(iter);
- rt_dump_vcpu(ops, svc);
+ rt_dump_unit(ops, svc);
}
printk("Global DepletedQueue info:\n");
list_for_each ( iter, depletedq )
{
svc = q_elem(iter);
- rt_dump_vcpu(ops, svc);
+ rt_dump_unit(ops, svc);
}
printk("Global Replenishment Events info:\n");
list_for_each ( iter, replq )
{
svc = replq_elem(iter);
- rt_dump_vcpu(ops, svc);
+ rt_dump_unit(ops, svc);
}
printk("Domain info:\n");
list_for_each ( iter, &prv->sdom )
{
- struct vcpu *v;
+ struct sched_unit *unit;
sdom = list_entry(iter, struct rt_dom, sdom_elem);
printk("\tdomain: %d\n", sdom->dom->domain_id);
- for_each_vcpu ( sdom->dom, v )
+ for_each_sched_unit ( sdom->dom, unit )
{
- svc = rt_unit(v->sched_unit);
- rt_dump_vcpu(ops, svc);
+ svc = rt_unit(unit);
+ rt_dump_unit(ops, svc);
}
}
@@ -457,12 +457,12 @@ rt_update_deadline(s_time_t now, struct rt_unit *svc)
/* TRACE */
{
struct __packed {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
unsigned priority_level;
uint64_t cur_deadline, cur_budget;
} d;
- d.dom = svc->vcpu->domain->domain_id;
- d.vcpu = svc->vcpu->vcpu_id;
+ d.dom = svc->unit->domain->domain_id;
+ d.unit = svc->unit->unit_id;
d.priority_level = svc->priority_level;
d.cur_deadline = (uint64_t) svc->cur_deadline;
d.cur_budget = (uint64_t) svc->cur_budget;
@@ -475,15 +475,15 @@ rt_update_deadline(s_time_t now, struct rt_unit *svc)
}
/*
- * Helpers for removing and inserting a vcpu in a queue
- * that is being kept ordered by the vcpus' deadlines (as EDF
+ * Helpers for removing and inserting an unit in a queue
+ * that is being kept ordered by the units' deadlines (as EDF
* mandates).
*
- * For callers' convenience, the vcpu removing helper returns
- * true if the vcpu removed was the one at the front of the
+ * For callers' convenience, the unit removing helper returns
+ * true if the unit removed was the one at the front of the
* queue; similarly, the inserting helper returns true if the
* inserted ended at the front of the queue (i.e., in both
- * cases, if the vcpu with the earliest deadline is what we
+ * cases, if the unit with the earliest deadline is what we
* are dealing with).
*/
static inline bool
@@ -509,7 +509,7 @@ deadline_queue_insert(struct rt_unit * (*qelem)(struct list_head *),
list_for_each ( iter, queue )
{
struct rt_unit * iter_svc = (*qelem)(iter);
- if ( compare_vcpu_priority(svc, iter_svc) > 0 )
+ if ( compare_unit_priority(svc, iter_svc) > 0 )
break;
pos++;
}
@@ -524,7 +524,7 @@ deadline_queue_insert(struct rt_unit * (*qelem)(struct list_head *),
static inline void
q_remove(struct rt_unit *svc)
{
- ASSERT( vcpu_on_q(svc) );
+ ASSERT( unit_on_q(svc) );
list_del_init(&svc->q_elem);
}
@@ -534,14 +534,14 @@ replq_remove(const struct scheduler *ops, struct rt_unit *svc)
struct rt_private *prv = rt_priv(ops);
struct list_head *replq = rt_replq(ops);
- ASSERT( vcpu_on_replq(svc) );
+ ASSERT( unit_on_replq(svc) );
if ( deadline_queue_remove(replq, &svc->replq_elem) )
{
/*
* The replenishment timer needs to be set to fire when a
- * replenishment for the vcpu at the front of the replenishment
- * queue is due. If it is such vcpu that we just removed, we may
+ * replenishment for the unit at the front of the replenishment
+ * queue is due. If it is such unit that we just removed, we may
* need to reprogram the timer.
*/
if ( !list_empty(replq) )
@@ -556,7 +556,7 @@ replq_remove(const struct scheduler *ops, struct rt_unit *svc)
/*
* Insert svc with budget in RunQ according to EDF:
- * vcpus with smaller deadlines go first.
+ * units with smaller deadlines go first.
* Insert svc without budget in DepletedQ unsorted;
*/
static void
@@ -566,8 +566,8 @@ runq_insert(const struct scheduler *ops, struct rt_unit *svc)
struct list_head *runq = rt_runq(ops);
ASSERT( spin_is_locked(&prv->lock) );
- ASSERT( !vcpu_on_q(svc) );
- ASSERT( vcpu_on_replq(svc) );
+ ASSERT( !unit_on_q(svc) );
+ ASSERT( unit_on_replq(svc) );
/* add svc to runq if svc still has budget or its extratime is set */
if ( svc->cur_budget > 0 ||
@@ -583,7 +583,7 @@ replq_insert(const struct scheduler *ops, struct rt_unit *svc)
struct list_head *replq = rt_replq(ops);
struct rt_private *prv = rt_priv(ops);
- ASSERT( !vcpu_on_replq(svc) );
+ ASSERT( !unit_on_replq(svc) );
/*
* The timer may be re-programmed if svc is inserted
@@ -606,12 +606,12 @@ replq_reinsert(const struct scheduler *ops, struct rt_unit *svc)
struct rt_unit *rearm_svc = svc;
bool_t rearm = 0;
- ASSERT( vcpu_on_replq(svc) );
+ ASSERT( unit_on_replq(svc) );
/*
* If svc was at the front of the replenishment queue, we certainly
* need to re-program the timer, and we want to use the deadline of
- * the vcpu which is now at the front of the queue (which may still
+ * the unit which is now at the front of the queue (which may still
* be svc or not).
*
* We may also need to re-program, if svc has been put at the front
@@ -631,24 +631,23 @@ replq_reinsert(const struct scheduler *ops, struct rt_unit *svc)
}
/*
- * Pick a valid resource for the vcpu vc
- * Valid resource of a vcpu is intesection of vcpu's affinity
+ * Pick a valid resource for the unit vc
+ * Valid resource of an unit is intesection of unit's affinity
* and available resources
*/
static struct sched_resource *
rt_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
cpumask_t cpus;
cpumask_t *online;
int cpu;
- online = cpupool_domain_cpumask(vc->domain);
+ online = cpupool_domain_cpumask(unit->domain);
cpumask_and(&cpus, online, unit->cpu_hard_affinity);
- cpu = cpumask_test_cpu(vc->processor, &cpus)
- ? vc->processor
- : cpumask_cycle(vc->processor, &cpus);
+ cpu = cpumask_test_cpu(sched_unit_cpu(unit), &cpus)
+ ? sched_unit_cpu(unit)
+ : cpumask_cycle(sched_unit_cpu(unit), &cpus);
ASSERT( !cpumask_empty(&cpus) && cpumask_test_cpu(cpu, &cpus) );
return get_sched_res(cpu);
@@ -737,7 +736,7 @@ rt_switch_sched(struct scheduler *new_ops, unsigned int cpu,
struct rt_unit *svc = vdata;
struct sched_resource *sd = get_sched_res(cpu);
- ASSERT(!pdata && svc && is_idle_vcpu(svc->vcpu));
+ ASSERT(!pdata && svc && is_idle_unit(svc->unit));
/*
* We are holding the runqueue lock already (it's been taken in
@@ -761,7 +760,7 @@ rt_switch_sched(struct scheduler *new_ops, unsigned int cpu,
dprintk(XENLOG_DEBUG, "RTDS: timer initialized on cpu %u\n", cpu);
}
- idle_vcpu[cpu]->sched_unit->priv = vdata;
+ sched_idle_unit(cpu)->priv = vdata;
return &prv->lock;
}
@@ -841,10 +840,9 @@ rt_free_domdata(const struct scheduler *ops, void *data)
static void *
rt_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit, void *dd)
{
- struct vcpu *vc = unit->vcpu_list;
struct rt_unit *svc;
- /* Allocate per-VCPU info */
+ /* Allocate per-UNIT info */
svc = xzalloc(struct rt_unit);
if ( svc == NULL )
return NULL;
@@ -853,13 +851,13 @@ rt_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit, void *dd)
INIT_LIST_HEAD(&svc->replq_elem);
svc->flags = 0U;
svc->sdom = dd;
- svc->vcpu = vc;
+ svc->unit = unit;
svc->last_start = 0;
__set_bit(__RTDS_extratime, &svc->flags);
svc->priority_level = 0;
svc->period = RTDS_DEFAULT_PERIOD;
- if ( !is_idle_vcpu(vc) )
+ if ( !is_idle_unit(unit) )
svc->budget = RTDS_DEFAULT_BUDGET;
SCHED_STAT_CRANK(unit_alloc);
@@ -879,22 +877,20 @@ rt_free_vdata(const struct scheduler *ops, void *priv)
* It is called in sched_move_domain() and sched_init_vcpu
* in schedule.c.
* When move a domain to a new cpupool.
- * It inserts vcpus of moving domain to the scheduler's RunQ in
+ * It inserts units of moving domain to the scheduler's RunQ in
* dest. cpupool.
*/
static void
rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct rt_unit *svc = rt_unit(unit);
s_time_t now;
spinlock_t *lock;
- BUG_ON( is_idle_vcpu(vc) );
+ BUG_ON( is_idle_unit(unit) );
- /* This is safe because vc isn't yet being scheduled */
- unit->res = rt_res_pick(ops, unit);
- vc->processor = unit->res->master_cpu;
+ /* This is safe because unit isn't yet being scheduled */
+ sched_set_res(unit, rt_res_pick(ops, unit));
lock = unit_schedule_lock_irq(unit);
@@ -902,7 +898,7 @@ rt_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
if ( now >= svc->cur_deadline )
rt_update_deadline(now, svc);
- if ( !vcpu_on_q(svc) && vcpu_runnable(vc) )
+ if ( !unit_on_q(svc) && unit_runnable(unit) )
{
replq_insert(ops, svc);
@@ -929,10 +925,10 @@ rt_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
BUG_ON( sdom == NULL );
lock = unit_schedule_lock_irq(unit);
- if ( vcpu_on_q(svc) )
+ if ( unit_on_q(svc) )
q_remove(svc);
- if ( vcpu_on_replq(svc) )
+ if ( unit_on_replq(svc) )
replq_remove(ops,svc);
unit_schedule_unlock_irq(lock, unit);
@@ -946,8 +942,8 @@ burn_budget(const struct scheduler *ops, struct rt_unit *svc, s_time_t now)
{
s_time_t delta;
- /* don't burn budget for idle VCPU */
- if ( is_idle_vcpu(svc->vcpu) )
+ /* don't burn budget for idle UNIT */
+ if ( is_idle_unit(svc->unit) )
return;
/* burn at nanoseconds level */
@@ -984,14 +980,14 @@ burn_budget(const struct scheduler *ops, struct rt_unit *svc, s_time_t now)
/* TRACE */
{
struct __packed {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
uint64_t cur_budget;
int delta;
unsigned priority_level;
bool has_extratime;
} d;
- d.dom = svc->vcpu->domain->domain_id;
- d.vcpu = svc->vcpu->vcpu_id;
+ d.dom = svc->unit->domain->domain_id;
+ d.unit = svc->unit->unit_id;
d.cur_budget = (uint64_t) svc->cur_budget;
d.delta = delta;
d.priority_level = svc->priority_level;
@@ -1021,9 +1017,8 @@ runq_pick(const struct scheduler *ops, const cpumask_t *mask)
iter_svc = q_elem(iter);
/* mask cpu_hard_affinity & cpupool & mask */
- online = cpupool_domain_cpumask(iter_svc->vcpu->domain);
- cpumask_and(&cpu_common, online,
- iter_svc->vcpu->sched_unit->cpu_hard_affinity);
+ online = cpupool_domain_cpumask(iter_svc->unit->domain);
+ cpumask_and(&cpu_common, online, iter_svc->unit->cpu_hard_affinity);
cpumask_and(&cpu_common, mask, &cpu_common);
if ( cpumask_empty(&cpu_common) )
continue;
@@ -1039,11 +1034,11 @@ runq_pick(const struct scheduler *ops, const cpumask_t *mask)
if( svc != NULL )
{
struct __packed {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
uint64_t cur_deadline, cur_budget;
} d;
- d.dom = svc->vcpu->domain->domain_id;
- d.vcpu = svc->vcpu->vcpu_id;
+ d.dom = svc->unit->domain->domain_id;
+ d.unit = svc->unit->unit_id;
d.cur_deadline = (uint64_t) svc->cur_deadline;
d.cur_budget = (uint64_t) svc->cur_budget;
trace_var(TRC_RTDS_RUNQ_PICK, 1,
@@ -1067,6 +1062,7 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
struct rt_unit *const scurr = rt_unit(current->sched_unit);
struct rt_unit *snext = NULL;
struct task_slice ret = { .migrated = 0 };
+ struct sched_unit *currunit = current->sched_unit;
/* TRACE */
{
@@ -1076,7 +1072,7 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
d.cpu = cpu;
d.tasklet = tasklet_work_scheduled;
d.tickled = cpumask_test_cpu(cpu, &prv->tickled);
- d.idle = is_idle_vcpu(current);
+ d.idle = is_idle_unit(currunit);
trace_var(TRC_RTDS_SCHEDULE, 1,
sizeof(d),
(unsigned char *)&d);
@@ -1085,72 +1081,70 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
/* clear ticked bit now that we've been scheduled */
cpumask_clear_cpu(cpu, &prv->tickled);
- /* burn_budget would return for IDLE VCPU */
+ /* burn_budget would return for IDLE UNIT */
burn_budget(ops, scurr, now);
if ( tasklet_work_scheduled )
{
trace_var(TRC_RTDS_SCHED_TASKLET, 1, 0, NULL);
- snext = rt_unit(idle_vcpu[cpu]->sched_unit);
+ snext = rt_unit(sched_idle_unit(cpu));
}
else
{
snext = runq_pick(ops, cpumask_of(cpu));
if ( snext == NULL )
- snext = rt_unit(idle_vcpu[cpu]->sched_unit);
+ snext = rt_unit(sched_idle_unit(cpu));
/* if scurr has higher priority and budget, still pick scurr */
- if ( !is_idle_vcpu(current) &&
- vcpu_runnable(current) &&
+ if ( !is_idle_unit(currunit) &&
+ unit_runnable(currunit) &&
scurr->cur_budget > 0 &&
- ( is_idle_vcpu(snext->vcpu) ||
- compare_vcpu_priority(scurr, snext) > 0 ) )
+ ( is_idle_unit(snext->unit) ||
+ compare_unit_priority(scurr, snext) > 0 ) )
snext = scurr;
}
if ( snext != scurr &&
- !is_idle_vcpu(current) &&
- vcpu_runnable(current) )
+ !is_idle_unit(currunit) &&
+ unit_runnable(currunit) )
__set_bit(__RTDS_delayed_runq_add, &scurr->flags);
snext->last_start = now;
- ret.time = -1; /* if an idle vcpu is picked */
- if ( !is_idle_vcpu(snext->vcpu) )
+ ret.time = -1; /* if an idle unit is picked */
+ if ( !is_idle_unit(snext->unit) )
{
if ( snext != scurr )
{
q_remove(snext);
__set_bit(__RTDS_scheduled, &snext->flags);
}
- if ( snext->vcpu->processor != cpu )
+ if ( sched_unit_cpu(snext->unit) != cpu )
{
- snext->vcpu->processor = cpu;
- snext->vcpu->sched_unit->res = get_sched_res(cpu);
+ sched_set_res(snext->unit, get_sched_res(cpu));
ret.migrated = 1;
}
ret.time = snext->cur_budget; /* invoke the scheduler next time */
}
- ret.task = snext->vcpu->sched_unit;
+ ret.task = snext->unit;
return ret;
}
/*
- * Remove VCPU from RunQ
+ * Remove UNIT from RunQ
* The lock is already grabbed in schedule.c, no need to lock here
*/
static void
rt_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct rt_unit * const svc = rt_unit(unit);
- BUG_ON( is_idle_vcpu(vc) );
+ BUG_ON( is_idle_unit(unit) );
SCHED_STAT_CRANK(unit_sleep);
- if ( curr_on_cpu(vc->processor) == unit )
- cpu_raise_softirq(vc->processor, SCHEDULE_SOFTIRQ);
- else if ( vcpu_on_q(svc) )
+ if ( curr_on_cpu(sched_unit_cpu(unit)) == unit )
+ cpu_raise_softirq(sched_unit_cpu(unit), SCHEDULE_SOFTIRQ);
+ else if ( unit_on_q(svc) )
{
q_remove(svc);
replq_remove(ops, svc);
@@ -1160,20 +1154,20 @@ rt_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
}
/*
- * Pick a cpu where to run a vcpu,
- * possibly kicking out the vcpu running there
+ * Pick a cpu where to run an unit,
+ * possibly kicking out the unit running there
* Called by wake() and context_saved()
* We have a running candidate here, the kick logic is:
* Among all the cpus that are within the cpu affinity
* 1) if there are any idle CPUs, kick one.
For cache benefit, we check new->cpu as first
* 2) now all pcpus are busy;
- * among all the running vcpus, pick lowest priority one
+ * among all the running units, pick lowest priority one
* if snext has higher priority, kick it.
*
* TODO:
- * 1) what if these two vcpus belongs to the same domain?
- * replace a vcpu belonging to the same domain introduces more overhead
+ * 1) what if these two units belongs to the same domain?
+ * replace an unit belonging to the same domain introduces more overhead
*
* lock is grabbed before calling this function
*/
@@ -1181,18 +1175,18 @@ static void
runq_tickle(const struct scheduler *ops, struct rt_unit *new)
{
struct rt_private *prv = rt_priv(ops);
- struct rt_unit *latest_deadline_vcpu = NULL; /* lowest priority */
+ struct rt_unit *latest_deadline_unit = NULL; /* lowest priority */
struct rt_unit *iter_svc;
- struct vcpu *iter_vc;
+ struct sched_unit *iter_unit;
int cpu = 0, cpu_to_tickle = 0;
cpumask_t not_tickled;
cpumask_t *online;
- if ( new == NULL || is_idle_vcpu(new->vcpu) )
+ if ( new == NULL || is_idle_unit(new->unit) )
return;
- online = cpupool_domain_cpumask(new->vcpu->domain);
- cpumask_and(¬_tickled, online, new->vcpu->sched_unit->cpu_hard_affinity);
+ online = cpupool_domain_cpumask(new->unit->domain);
+ cpumask_and(¬_tickled, online, new->unit->cpu_hard_affinity);
cpumask_andnot(¬_tickled, ¬_tickled, &prv->tickled);
/*
@@ -1200,31 +1194,31 @@ runq_tickle(const struct scheduler *ops, struct rt_unit *new)
* For cache benefit,we first search new->cpu.
* The same loop also find the one with lowest priority.
*/
- cpu = cpumask_test_or_cycle(new->vcpu->processor, ¬_tickled);
+ cpu = cpumask_test_or_cycle(sched_unit_cpu(new->unit), ¬_tickled);
while ( cpu!= nr_cpu_ids )
{
- iter_vc = curr_on_cpu(cpu)->vcpu_list;
- if ( is_idle_vcpu(iter_vc) )
+ iter_unit = curr_on_cpu(cpu);
+ if ( is_idle_unit(iter_unit) )
{
SCHED_STAT_CRANK(tickled_idle_cpu);
cpu_to_tickle = cpu;
goto out;
}
- iter_svc = rt_unit(iter_vc->sched_unit);
- if ( latest_deadline_vcpu == NULL ||
- compare_vcpu_priority(iter_svc, latest_deadline_vcpu) < 0 )
- latest_deadline_vcpu = iter_svc;
+ iter_svc = rt_unit(iter_unit);
+ if ( latest_deadline_unit == NULL ||
+ compare_unit_priority(iter_svc, latest_deadline_unit) < 0 )
+ latest_deadline_unit = iter_svc;
cpumask_clear_cpu(cpu, ¬_tickled);
cpu = cpumask_cycle(cpu, ¬_tickled);
}
- /* 2) candicate has higher priority, kick out lowest priority vcpu */
- if ( latest_deadline_vcpu != NULL &&
- compare_vcpu_priority(latest_deadline_vcpu, new) < 0 )
+ /* 2) candicate has higher priority, kick out lowest priority unit */
+ if ( latest_deadline_unit != NULL &&
+ compare_unit_priority(latest_deadline_unit, new) < 0 )
{
SCHED_STAT_CRANK(tickled_busy_cpu);
- cpu_to_tickle = latest_deadline_vcpu->vcpu->processor;
+ cpu_to_tickle = sched_unit_cpu(latest_deadline_unit->unit);
goto out;
}
@@ -1250,35 +1244,34 @@ runq_tickle(const struct scheduler *ops, struct rt_unit *new)
}
/*
- * Should always wake up runnable vcpu, put it back to RunQ.
+ * Should always wake up runnable unit, put it back to RunQ.
* Check priority to raise interrupt
* The lock is already grabbed in schedule.c, no need to lock here
- * TODO: what if these two vcpus belongs to the same domain?
+ * TODO: what if these two units belongs to the same domain?
*/
static void
rt_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct rt_unit * const svc = rt_unit(unit);
s_time_t now;
bool_t missed;
- BUG_ON( is_idle_vcpu(vc) );
+ BUG_ON( is_idle_unit(unit) );
- if ( unlikely(curr_on_cpu(vc->processor) == unit) )
+ if ( unlikely(curr_on_cpu(sched_unit_cpu(unit)) == unit) )
{
SCHED_STAT_CRANK(unit_wake_running);
return;
}
/* on RunQ/DepletedQ, just update info is ok */
- if ( unlikely(vcpu_on_q(svc)) )
+ if ( unlikely(unit_on_q(svc)) )
{
SCHED_STAT_CRANK(unit_wake_onrunq);
return;
}
- if ( likely(vcpu_runnable(vc)) )
+ if ( likely(unit_runnable(unit)) )
SCHED_STAT_CRANK(unit_wake_runnable);
else
SCHED_STAT_CRANK(unit_wake_not_runnable);
@@ -1294,16 +1287,16 @@ rt_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
rt_update_deadline(now, svc);
/*
- * If context hasn't been saved for this vcpu yet, we can't put it on
+ * If context hasn't been saved for this unit yet, we can't put it on
* the run-queue/depleted-queue. Instead, we set the appropriate flag,
- * the vcpu will be put back on queue after the context has been saved
+ * the unit will be put back on queue after the context has been saved
* (in rt_context_save()).
*/
if ( unlikely(svc->flags & RTDS_scheduled) )
{
__set_bit(__RTDS_delayed_runq_add, &svc->flags);
/*
- * The vcpu is waking up already, and we didn't even had the time to
+ * The unit is waking up already, and we didn't even had the time to
* remove its next replenishment event from the replenishment queue
* when it blocked! No big deal. If we did not miss the deadline in
* the meantime, let's just leave it there. If we did, let's remove it
@@ -1324,22 +1317,21 @@ rt_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
/*
* scurr has finished context switch, insert it back to the RunQ,
- * and then pick the highest priority vcpu from runq to run
+ * and then pick the highest priority unit from runq to run
*/
static void
rt_context_saved(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct rt_unit *svc = rt_unit(unit);
spinlock_t *lock = unit_schedule_lock_irq(unit);
__clear_bit(__RTDS_scheduled, &svc->flags);
- /* not insert idle vcpu to runq */
- if ( is_idle_vcpu(vc) )
+ /* not insert idle unit to runq */
+ if ( is_idle_unit(unit) )
goto out;
if ( __test_and_clear_bit(__RTDS_delayed_runq_add, &svc->flags) &&
- likely(vcpu_runnable(vc)) )
+ likely(unit_runnable(unit)) )
{
runq_insert(ops, svc);
runq_tickle(ops, svc);
@@ -1352,7 +1344,7 @@ out:
}
/*
- * set/get each vcpu info of each domain
+ * set/get each unit info of each domain
*/
static int
rt_dom_cntl(
@@ -1362,7 +1354,7 @@ rt_dom_cntl(
{
struct rt_private *prv = rt_priv(ops);
struct rt_unit *svc;
- struct vcpu *v;
+ struct sched_unit *unit;
unsigned long flags;
int rc = 0;
struct xen_domctl_schedparam_vcpu local_sched;
@@ -1383,9 +1375,9 @@ rt_dom_cntl(
break;
}
spin_lock_irqsave(&prv->lock, flags);
- for_each_vcpu ( d, v )
+ for_each_sched_unit ( d, unit )
{
- svc = rt_unit(v->sched_unit);
+ svc = rt_unit(unit);
svc->period = MICROSECS(op->u.rtds.period); /* transfer to nanosec */
svc->budget = MICROSECS(op->u.rtds.budget);
}
@@ -1453,7 +1445,7 @@ rt_dom_cntl(
break;
}
if ( !rc )
- /* notify upper caller how many vcpus have been processed. */
+ /* notify upper caller how many units have been processed. */
op->u.v.nr_vcpus = index;
break;
}
@@ -1462,7 +1454,7 @@ rt_dom_cntl(
}
/*
- * The replenishment timer handler picks vcpus
+ * The replenishment timer handler picks units
* from the replq and does the actual replenishment.
*/
static void repl_timer_handler(void *data){
@@ -1480,7 +1472,7 @@ static void repl_timer_handler(void *data){
now = NOW();
/*
- * Do the replenishment and move replenished vcpus
+ * Do the replenishment and move replenished units
* to the temporary list to tickle.
* If svc is on run queue, we need to put it at
* the correct place since its deadline changes.
@@ -1496,7 +1488,7 @@ static void repl_timer_handler(void *data){
rt_update_deadline(now, svc);
list_add(&svc->replq_elem, &tmp_replq);
- if ( vcpu_on_q(svc) )
+ if ( unit_on_q(svc) )
{
q_remove(svc);
runq_insert(ops, svc);
@@ -1504,26 +1496,26 @@ static void repl_timer_handler(void *data){
}
/*
- * Iterate through the list of updated vcpus.
- * If an updated vcpu is running, tickle the head of the
+ * Iterate through the list of updated units.
+ * If an updated unit is running, tickle the head of the
* runqueue if it has a higher priority.
- * If an updated vcpu was depleted and on the runqueue, tickle it.
- * Finally, reinsert the vcpus back to replenishement events list.
+ * If an updated unit was depleted and on the runqueue, tickle it.
+ * Finally, reinsert the units back to replenishement events list.
*/
list_for_each_safe ( iter, tmp, &tmp_replq )
{
svc = replq_elem(iter);
- if ( curr_on_cpu(svc->vcpu->processor) == svc->vcpu->sched_unit &&
+ if ( curr_on_cpu(sched_unit_cpu(svc->unit)) == svc->unit &&
!list_empty(runq) )
{
struct rt_unit *next_on_runq = q_elem(runq->next);
- if ( compare_vcpu_priority(svc, next_on_runq) < 0 )
+ if ( compare_unit_priority(svc, next_on_runq) < 0 )
runq_tickle(ops, next_on_runq);
}
else if ( __test_and_clear_bit(__RTDS_depleted, &svc->flags) &&
- vcpu_on_q(svc) )
+ unit_on_q(svc) )
runq_tickle(ops, svc);
list_del(&svc->replq_elem);
@@ -1531,7 +1523,7 @@ static void repl_timer_handler(void *data){
}
/*
- * If there are vcpus left in the replenishment event list,
+ * If there are units left in the replenishment event list,
* set the next replenishment to happen at the deadline of
* the one in the front.
*/
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 16/47] xen/sched: make credit scheduler vcpu agnostic.
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (14 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 15/47] xen/sched: make rt " Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-25 14:21 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 17/47] xen/sched: make credit2 " Juergen Gross
` (32 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Dario Faggioli
Switch credit scheduler completely from vcpu to sched_unit usage.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/sched_credit.c | 503 +++++++++++++++++++++++-----------------------
1 file changed, 250 insertions(+), 253 deletions(-)
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index c0f6ef831e..044b1d8a51 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -70,10 +70,10 @@
* inconsistent set of locks. Therefore atomic-safe bit operations must
* be used for accessing it.
*/
-#define CSCHED_FLAG_VCPU_PARKED 0x0 /* VCPU over capped credits */
-#define CSCHED_FLAG_VCPU_YIELD 0x1 /* VCPU yielding */
-#define CSCHED_FLAG_VCPU_MIGRATING 0x2 /* VCPU may have moved to a new pcpu */
-#define CSCHED_FLAG_VCPU_PINNED 0x4 /* VCPU can run only on 1 pcpu */
+#define CSCHED_FLAG_UNIT_PARKED 0x0 /* UNIT over capped credits */
+#define CSCHED_FLAG_UNIT_YIELD 0x1 /* UNIT yielding */
+#define CSCHED_FLAG_UNIT_MIGRATING 0x2 /* UNIT may have moved to a new pcpu */
+#define CSCHED_FLAG_UNIT_PINNED 0x4 /* UNIT can run only on 1 pcpu */
/*
@@ -91,7 +91,7 @@
/*
* CSCHED_STATS
*
- * Manage very basic per-vCPU counters and stats.
+ * Manage very basic per-unit counters and stats.
*
* Useful for debugging live systems. The stats are displayed
* with runq dumps ('r' on the Xen console).
@@ -100,23 +100,23 @@
#define CSCHED_STATS
-#define SCHED_VCPU_STATS_RESET(_V) \
+#define SCHED_UNIT_STATS_RESET(_V) \
do \
{ \
memset(&(_V)->stats, 0, sizeof((_V)->stats)); \
} while ( 0 )
-#define SCHED_VCPU_STAT_CRANK(_V, _X) (((_V)->stats._X)++)
+#define SCHED_UNIT_STAT_CRANK(_V, _X) (((_V)->stats._X)++)
-#define SCHED_VCPU_STAT_SET(_V, _X, _Y) (((_V)->stats._X) = (_Y))
+#define SCHED_UNIT_STAT_SET(_V, _X, _Y) (((_V)->stats._X) = (_Y))
#else /* !SCHED_STATS */
#undef CSCHED_STATS
-#define SCHED_VCPU_STATS_RESET(_V) do {} while ( 0 )
-#define SCHED_VCPU_STAT_CRANK(_V, _X) do {} while ( 0 )
-#define SCHED_VCPU_STAT_SET(_V, _X, _Y) do {} while ( 0 )
+#define SCHED_UNIT_STATS_RESET(_V) do {} while ( 0 )
+#define SCHED_UNIT_STAT_CRANK(_V, _X) do {} while ( 0 )
+#define SCHED_UNIT_STAT_SET(_V, _X, _Y) do {} while ( 0 )
#endif /* SCHED_STATS */
@@ -128,7 +128,7 @@
#define TRC_CSCHED_SCHED_TASKLET TRC_SCHED_CLASS_EVT(CSCHED, 1)
#define TRC_CSCHED_ACCOUNT_START TRC_SCHED_CLASS_EVT(CSCHED, 2)
#define TRC_CSCHED_ACCOUNT_STOP TRC_SCHED_CLASS_EVT(CSCHED, 3)
-#define TRC_CSCHED_STOLEN_VCPU TRC_SCHED_CLASS_EVT(CSCHED, 4)
+#define TRC_CSCHED_STOLEN_UNIT TRC_SCHED_CLASS_EVT(CSCHED, 4)
#define TRC_CSCHED_PICKED_CPU TRC_SCHED_CLASS_EVT(CSCHED, 5)
#define TRC_CSCHED_TICKLE TRC_SCHED_CLASS_EVT(CSCHED, 6)
#define TRC_CSCHED_BOOST_START TRC_SCHED_CLASS_EVT(CSCHED, 7)
@@ -158,15 +158,15 @@ struct csched_pcpu {
};
/*
- * Virtual CPU
+ * Virtual UNIT
*/
struct csched_unit {
struct list_head runq_elem;
- struct list_head active_vcpu_elem;
+ struct list_head active_unit_elem;
/* Up-pointers */
struct csched_dom *sdom;
- struct vcpu *vcpu;
+ struct sched_unit *unit;
s_time_t start_time; /* When we were scheduled (used for credit) */
unsigned flags;
@@ -194,10 +194,10 @@ struct csched_unit {
* Domain
*/
struct csched_dom {
- struct list_head active_vcpu;
+ struct list_head active_unit;
struct list_head active_sdom_elem;
struct domain *dom;
- uint16_t active_vcpu_count;
+ uint16_t active_unit_count;
uint16_t weight;
uint16_t cap;
};
@@ -217,7 +217,7 @@ struct csched_private {
/* Period of master and tick in milliseconds */
unsigned int tick_period_us, ticks_per_tslice;
- s_time_t ratelimit, tslice, vcpu_migr_delay;
+ s_time_t ratelimit, tslice, unit_migr_delay;
struct list_head active_sdom;
uint32_t weight;
@@ -233,7 +233,7 @@ static void csched_tick(void *_cpu);
static void csched_acct(void *dummy);
static inline int
-__vcpu_on_runq(struct csched_unit *svc)
+__unit_on_runq(struct csched_unit *svc)
{
return !list_empty(&svc->runq_elem);
}
@@ -244,7 +244,7 @@ __runq_elem(struct list_head *elem)
return list_entry(elem, struct csched_unit, runq_elem);
}
-/* Is the first element of cpu's runq (if any) cpu's idle vcpu? */
+/* Is the first element of cpu's runq (if any) cpu's idle unit? */
static inline bool_t is_runq_idle(unsigned int cpu)
{
/*
@@ -253,7 +253,7 @@ static inline bool_t is_runq_idle(unsigned int cpu)
ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
return list_empty(RUNQ(cpu)) ||
- is_idle_vcpu(__runq_elem(RUNQ(cpu)->next)->vcpu);
+ is_idle_unit(__runq_elem(RUNQ(cpu)->next)->unit);
}
static inline void
@@ -275,11 +275,11 @@ dec_nr_runnable(unsigned int cpu)
static inline void
__runq_insert(struct csched_unit *svc)
{
- unsigned int cpu = svc->vcpu->processor;
+ unsigned int cpu = sched_unit_cpu(svc->unit);
const struct list_head * const runq = RUNQ(cpu);
struct list_head *iter;
- BUG_ON( __vcpu_on_runq(svc) );
+ BUG_ON( __unit_on_runq(svc) );
list_for_each( iter, runq )
{
@@ -288,10 +288,10 @@ __runq_insert(struct csched_unit *svc)
break;
}
- /* If the vcpu yielded, try to put it behind one lower-priority
- * runnable vcpu if we can. The next runq_sort will bring it forward
+ /* If the unit yielded, try to put it behind one lower-priority
+ * runnable unit if we can. The next runq_sort will bring it forward
* within 30ms if the queue too long. */
- if ( test_bit(CSCHED_FLAG_VCPU_YIELD, &svc->flags)
+ if ( test_bit(CSCHED_FLAG_UNIT_YIELD, &svc->flags)
&& __runq_elem(iter)->pri > CSCHED_PRI_IDLE )
{
iter=iter->next;
@@ -307,20 +307,20 @@ static inline void
runq_insert(struct csched_unit *svc)
{
__runq_insert(svc);
- inc_nr_runnable(svc->vcpu->processor);
+ inc_nr_runnable(sched_unit_cpu(svc->unit));
}
static inline void
__runq_remove(struct csched_unit *svc)
{
- BUG_ON( !__vcpu_on_runq(svc) );
+ BUG_ON( !__unit_on_runq(svc) );
list_del_init(&svc->runq_elem);
}
static inline void
runq_remove(struct csched_unit *svc)
{
- dec_nr_runnable(svc->vcpu->processor);
+ dec_nr_runnable(sched_unit_cpu(svc->unit));
__runq_remove(svc);
}
@@ -331,7 +331,7 @@ static void burn_credits(struct csched_unit *svc, s_time_t now)
unsigned int credits;
/* Assert svc is current */
- ASSERT( svc == CSCHED_UNIT(curr_on_cpu(svc->vcpu->processor)) );
+ ASSERT( svc == CSCHED_UNIT(curr_on_cpu(sched_unit_cpu(svc->unit))) );
if ( (delta = now - svc->start_time) <= 0 )
return;
@@ -351,8 +351,8 @@ DEFINE_PER_CPU(unsigned int, last_tickle_cpu);
static inline void __runq_tickle(struct csched_unit *new)
{
- unsigned int cpu = new->vcpu->processor;
- struct sched_unit *unit = new->vcpu->sched_unit;
+ unsigned int cpu = sched_unit_cpu(new->unit);
+ struct sched_unit *unit = new->unit;
struct csched_unit * const cur = CSCHED_UNIT(curr_on_cpu(cpu));
struct csched_private *prv = CSCHED_PRIV(per_cpu(scheduler, cpu));
cpumask_t mask, idle_mask, *online;
@@ -366,16 +366,16 @@ static inline void __runq_tickle(struct csched_unit *new)
idlers_empty = cpumask_empty(&idle_mask);
/*
- * Exclusive pinning is when a vcpu has hard-affinity with only one
- * cpu, and there is no other vcpu that has hard-affinity with that
+ * Exclusive pinning is when a unit has hard-affinity with only one
+ * cpu, and there is no other unit that has hard-affinity with that
* same cpu. This is infrequent, but if it happens, is for achieving
* the most possible determinism, and least possible overhead for
- * the vcpus in question.
+ * the units in question.
*
* Try to identify the vast majority of these situations, and deal
* with them quickly.
*/
- if ( unlikely(test_bit(CSCHED_FLAG_VCPU_PINNED, &new->flags) &&
+ if ( unlikely(test_bit(CSCHED_FLAG_UNIT_PINNED, &new->flags) &&
cpumask_test_cpu(cpu, &idle_mask)) )
{
ASSERT(cpumask_cycle(cpu, unit->cpu_hard_affinity) == cpu);
@@ -386,7 +386,7 @@ static inline void __runq_tickle(struct csched_unit *new)
/*
* If the pcpu is idle, or there are no idlers and the new
- * vcpu is a higher priority than the old vcpu, run it here.
+ * unit is a higher priority than the old unit, run it here.
*
* If there are idle cpus, first try to find one suitable to run
* new, so we can avoid preempting cur. If we cannot find a
@@ -405,7 +405,7 @@ static inline void __runq_tickle(struct csched_unit *new)
else if ( !idlers_empty )
{
/*
- * Soft and hard affinity balancing loop. For vcpus without
+ * Soft and hard affinity balancing loop. For units without
* a useful soft affinity, consider hard affinity only.
*/
for_each_affinity_balance_step( balance_step )
@@ -448,10 +448,10 @@ static inline void __runq_tickle(struct csched_unit *new)
{
if ( cpumask_intersects(unit->cpu_hard_affinity, &idle_mask) )
{
- SCHED_VCPU_STAT_CRANK(cur, kicked_away);
- SCHED_VCPU_STAT_CRANK(cur, migrate_r);
+ SCHED_UNIT_STAT_CRANK(cur, kicked_away);
+ SCHED_UNIT_STAT_CRANK(cur, migrate_r);
SCHED_STAT_CRANK(migrate_kicked_away);
- set_bit(_VPF_migrating, &cur->vcpu->pause_flags);
+ sched_set_pause_flags_atomic(cur->unit, _VPF_migrating);
}
/* Tickle cpu anyway, to let new preempt cur. */
SCHED_STAT_CRANK(tickled_busy_cpu);
@@ -607,7 +607,7 @@ init_pdata(struct csched_private *prv, struct csched_pcpu *spc, int cpu)
spc->idle_bias = nr_cpu_ids - 1;
/* Start off idling... */
- BUG_ON(!is_idle_vcpu(curr_on_cpu(cpu)->vcpu_list));
+ BUG_ON(!is_idle_unit(curr_on_cpu(cpu)));
cpumask_set_cpu(cpu, prv->idlers);
spc->nr_runnable = 0;
}
@@ -632,9 +632,9 @@ csched_switch_sched(struct scheduler *new_ops, unsigned int cpu,
struct csched_private *prv = CSCHED_PRIV(new_ops);
struct csched_unit *svc = vdata;
- ASSERT(svc && is_idle_vcpu(svc->vcpu));
+ ASSERT(svc && is_idle_unit(svc->unit));
- idle_vcpu[cpu]->sched_unit->priv = vdata;
+ sched_idle_unit(cpu)->priv = vdata;
/*
* We are holding the runqueue lock already (it's been taken in
@@ -651,33 +651,33 @@ csched_switch_sched(struct scheduler *new_ops, unsigned int cpu,
#ifndef NDEBUG
static inline void
-__csched_vcpu_check(struct vcpu *vc)
+__csched_unit_check(struct sched_unit *unit)
{
- struct csched_unit * const svc = CSCHED_UNIT(vc->sched_unit);
+ struct csched_unit * const svc = CSCHED_UNIT(unit);
struct csched_dom * const sdom = svc->sdom;
- BUG_ON( svc->vcpu != vc );
- BUG_ON( sdom != CSCHED_DOM(vc->domain) );
+ BUG_ON( svc->unit != unit );
+ BUG_ON( sdom != CSCHED_DOM(unit->domain) );
if ( sdom )
{
- BUG_ON( is_idle_vcpu(vc) );
- BUG_ON( sdom->dom != vc->domain );
+ BUG_ON( is_idle_unit(unit) );
+ BUG_ON( sdom->dom != unit->domain );
}
else
{
- BUG_ON( !is_idle_vcpu(vc) );
+ BUG_ON( !is_idle_unit(unit) );
}
SCHED_STAT_CRANK(unit_check);
}
-#define CSCHED_VCPU_CHECK(_vc) (__csched_vcpu_check(_vc))
+#define CSCHED_UNIT_CHECK(unit) (__csched_unit_check(unit))
#else
-#define CSCHED_VCPU_CHECK(_vc)
+#define CSCHED_UNIT_CHECK(unit)
#endif
/*
- * Delay, in microseconds, between migrations of a VCPU between PCPUs.
- * This prevents rapid fluttering of a VCPU between CPUs, and reduces the
+ * Delay, in microseconds, between migrations of a UNIT between PCPUs.
+ * This prevents rapid fluttering of a UNIT between CPUs, and reduces the
* implicit overheads such as cache-warming. 1ms (1000) has been measured
* as a good value.
*/
@@ -688,8 +688,8 @@ static inline bool
__csched_vcpu_is_cache_hot(const struct csched_private *prv,
const struct csched_unit *svc)
{
- bool hot = prv->vcpu_migr_delay &&
- (NOW() - svc->last_sched_time) < prv->vcpu_migr_delay;
+ bool hot = prv->unit_migr_delay &&
+ (NOW() - svc->last_sched_time) < prv->unit_migr_delay;
if ( hot )
SCHED_STAT_CRANK(unit_hot);
@@ -698,37 +698,39 @@ __csched_vcpu_is_cache_hot(const struct csched_private *prv,
}
static inline int
-__csched_vcpu_is_migrateable(const struct csched_private *prv, struct vcpu *vc,
+__csched_unit_is_migrateable(const struct csched_private *prv,
+ struct sched_unit *unit,
int dest_cpu, cpumask_t *mask)
{
- const struct csched_unit *svc = CSCHED_UNIT(vc->sched_unit);
+ const struct csched_unit *svc = CSCHED_UNIT(unit);
/*
* Don't pick up work that's hot on peer PCPU, or that can't (or
* would prefer not to) run on cpu.
*
- * The caller is supposed to have already checked that vc is also
+ * The caller is supposed to have already checked that unit is also
* not running.
*/
- ASSERT(!vc->sched_unit->is_running);
+ ASSERT(!unit->is_running);
return !__csched_vcpu_is_cache_hot(prv, svc) &&
cpumask_test_cpu(dest_cpu, mask);
}
static int
-_csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc, bool_t commit)
+_csched_cpu_pick(const struct scheduler *ops, const struct sched_unit *unit,
+ bool_t commit)
{
- /* We must always use vc->procssor's scratch space */
- cpumask_t *cpus = cpumask_scratch_cpu(vc->processor);
+ int cpu = sched_unit_cpu(unit);
+ /* We must always use cpu's scratch space */
+ cpumask_t *cpus = cpumask_scratch_cpu(cpu);
cpumask_t idlers;
- cpumask_t *online = cpupool_domain_cpumask(vc->domain);
+ cpumask_t *online = cpupool_domain_cpumask(unit->domain);
struct csched_pcpu *spc = NULL;
- int cpu = vc->processor;
int balance_step;
for_each_affinity_balance_step( balance_step )
{
- affinity_balance_cpumask(vc->sched_unit, balance_step, cpus);
+ affinity_balance_cpumask(unit, balance_step, cpus);
cpumask_and(cpus, online, cpus);
/*
* We want to pick up a pcpu among the ones that are online and
@@ -747,12 +749,13 @@ _csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc, bool_t commit)
* balancing step all together.
*/
if ( balance_step == BALANCE_SOFT_AFFINITY &&
- (!has_soft_affinity(vc->sched_unit) || cpumask_empty(cpus)) )
+ (!has_soft_affinity(unit) || cpumask_empty(cpus)) )
continue;
/* If present, prefer vc's current processor */
- cpu = cpumask_test_cpu(vc->processor, cpus)
- ? vc->processor : cpumask_cycle(vc->processor, cpus);
+ cpu = cpumask_test_cpu(sched_unit_cpu(unit), cpus)
+ ? sched_unit_cpu(unit)
+ : cpumask_cycle(sched_unit_cpu(unit), cpus);
ASSERT(cpumask_test_cpu(cpu, cpus));
/*
@@ -764,15 +767,15 @@ _csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc, bool_t commit)
* We give preference to the idle execution vehicle with the most
* idling neighbours in its grouping. This distributes work across
* distinct cores first and guarantees we don't do something stupid
- * like run two VCPUs on co-hyperthreads while there are idle cores
+ * like run two UNITs on co-hyperthreads while there are idle cores
* or sockets.
*
* Notice that, when computing the "idleness" of cpu, we may want to
- * discount vc. That is, iff vc is the currently running and the only
- * runnable vcpu on cpu, we add cpu to the idlers.
+ * discount unit. That is, iff unit is the currently running and the
+ * only runnable unit on cpu, we add cpu to the idlers.
*/
cpumask_and(&idlers, &cpu_online_map, CSCHED_PRIV(ops)->idlers);
- if ( vc->processor == cpu && is_runq_idle(cpu) )
+ if ( sched_unit_cpu(unit) == cpu && is_runq_idle(cpu) )
__cpumask_set_cpu(cpu, &idlers);
cpumask_and(cpus, &idlers, cpus);
@@ -782,7 +785,7 @@ _csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc, bool_t commit)
* CPU, as we just &&-ed it with idlers). In fact, if we are on SMT, and
* cpu points to a busy thread with an idle sibling, both the threads
* will be considered the same, from the "idleness" calculation point
- * of view", preventing vcpu from being moved to the thread that is
+ * of view", preventing unit from being moved to the thread that is
* actually idle.
*
* Notice that cpumask_test_cpu() is quicker than cpumask_empty(), so
@@ -848,7 +851,8 @@ _csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc, bool_t commit)
if ( commit && spc )
spc->idle_bias = cpu;
- TRACE_3D(TRC_CSCHED_PICKED_CPU, vc->domain->domain_id, vc->vcpu_id, cpu);
+ TRACE_3D(TRC_CSCHED_PICKED_CPU, unit->domain->domain_id, unit->unit_id,
+ cpu);
return cpu;
}
@@ -856,7 +860,6 @@ _csched_cpu_pick(const struct scheduler *ops, struct vcpu *vc, bool_t commit)
static struct sched_resource *
csched_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched_unit *svc = CSCHED_UNIT(unit);
/*
@@ -866,26 +869,26 @@ csched_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
* csched_unit_wake() (still called from vcpu_migrate()) we won't
* get boosted, which we don't deserve as we are "only" migrating.
*/
- set_bit(CSCHED_FLAG_VCPU_MIGRATING, &svc->flags);
- return get_sched_res(_csched_cpu_pick(ops, vc, 1));
+ set_bit(CSCHED_FLAG_UNIT_MIGRATING, &svc->flags);
+ return get_sched_res(_csched_cpu_pick(ops, unit, 1));
}
static inline void
-__csched_vcpu_acct_start(struct csched_private *prv, struct csched_unit *svc)
+__csched_unit_acct_start(struct csched_private *prv, struct csched_unit *svc)
{
struct csched_dom * const sdom = svc->sdom;
unsigned long flags;
spin_lock_irqsave(&prv->lock, flags);
- if ( list_empty(&svc->active_vcpu_elem) )
+ if ( list_empty(&svc->active_unit_elem) )
{
- SCHED_VCPU_STAT_CRANK(svc, state_active);
+ SCHED_UNIT_STAT_CRANK(svc, state_active);
SCHED_STAT_CRANK(acct_unit_active);
- sdom->active_vcpu_count++;
- list_add(&svc->active_vcpu_elem, &sdom->active_vcpu);
- /* Make weight per-vcpu */
+ sdom->active_unit_count++;
+ list_add(&svc->active_unit_elem, &sdom->active_unit);
+ /* Make weight per-unit */
prv->weight += sdom->weight;
if ( list_empty(&sdom->active_sdom_elem) )
{
@@ -894,56 +897,56 @@ __csched_vcpu_acct_start(struct csched_private *prv, struct csched_unit *svc)
}
TRACE_3D(TRC_CSCHED_ACCOUNT_START, sdom->dom->domain_id,
- svc->vcpu->vcpu_id, sdom->active_vcpu_count);
+ svc->unit->unit_id, sdom->active_unit_count);
spin_unlock_irqrestore(&prv->lock, flags);
}
static inline void
-__csched_vcpu_acct_stop_locked(struct csched_private *prv,
+__csched_unit_acct_stop_locked(struct csched_private *prv,
struct csched_unit *svc)
{
struct csched_dom * const sdom = svc->sdom;
- BUG_ON( list_empty(&svc->active_vcpu_elem) );
+ BUG_ON( list_empty(&svc->active_unit_elem) );
- SCHED_VCPU_STAT_CRANK(svc, state_idle);
+ SCHED_UNIT_STAT_CRANK(svc, state_idle);
SCHED_STAT_CRANK(acct_unit_idle);
BUG_ON( prv->weight < sdom->weight );
- sdom->active_vcpu_count--;
- list_del_init(&svc->active_vcpu_elem);
+ sdom->active_unit_count--;
+ list_del_init(&svc->active_unit_elem);
prv->weight -= sdom->weight;
- if ( list_empty(&sdom->active_vcpu) )
+ if ( list_empty(&sdom->active_unit) )
{
list_del_init(&sdom->active_sdom_elem);
}
TRACE_3D(TRC_CSCHED_ACCOUNT_STOP, sdom->dom->domain_id,
- svc->vcpu->vcpu_id, sdom->active_vcpu_count);
+ svc->unit->unit_id, sdom->active_unit_count);
}
static void
-csched_vcpu_acct(struct csched_private *prv, unsigned int cpu)
+csched_unit_acct(struct csched_private *prv, unsigned int cpu)
{
struct sched_unit *currunit = current->sched_unit;
struct csched_unit * const svc = CSCHED_UNIT(currunit);
const struct scheduler *ops = per_cpu(scheduler, cpu);
- ASSERT( current->processor == cpu );
+ ASSERT( sched_unit_cpu(currunit) == cpu );
ASSERT( svc->sdom != NULL );
- ASSERT( !is_idle_vcpu(svc->vcpu) );
+ ASSERT( !is_idle_unit(svc->unit) );
/*
- * If this VCPU's priority was boosted when it last awoke, reset it.
- * If the VCPU is found here, then it's consuming a non-negligeable
+ * If this UNIT's priority was boosted when it last awoke, reset it.
+ * If the UNIT is found here, then it's consuming a non-negligeable
* amount of CPU resources and should no longer be boosted.
*/
if ( svc->pri == CSCHED_PRI_TS_BOOST )
{
svc->pri = CSCHED_PRI_TS_UNDER;
TRACE_2D(TRC_CSCHED_BOOST_END, svc->sdom->dom->domain_id,
- svc->vcpu->vcpu_id);
+ svc->unit->unit_id);
}
/*
@@ -952,12 +955,12 @@ csched_vcpu_acct(struct csched_private *prv, unsigned int cpu)
burn_credits(svc, NOW());
/*
- * Put this VCPU and domain back on the active list if it was
+ * Put this UNIT and domain back on the active list if it was
* idling.
*/
- if ( list_empty(&svc->active_vcpu_elem) )
+ if ( list_empty(&svc->active_unit_elem) )
{
- __csched_vcpu_acct_start(prv, svc);
+ __csched_unit_acct_start(prv, svc);
}
else
{
@@ -970,15 +973,15 @@ csched_vcpu_acct(struct csched_private *prv, unsigned int cpu)
* migrating it to run elsewhere (see multi-core and multi-thread
* support in csched_res_pick()).
*/
- new_cpu = _csched_cpu_pick(ops, current, 0);
+ new_cpu = _csched_cpu_pick(ops, currunit, 0);
unit_schedule_unlock_irqrestore(lock, flags, currunit);
if ( new_cpu != cpu )
{
- SCHED_VCPU_STAT_CRANK(svc, migrate_r);
+ SCHED_UNIT_STAT_CRANK(svc, migrate_r);
SCHED_STAT_CRANK(migrate_running);
- set_bit(_VPF_migrating, ¤t->pause_flags);
+ sched_set_pause_flags_atomic(currunit, _VPF_migrating);
/*
* As we are about to tickle cpu, we should clear its bit in
* idlers. But, if we are here, it means there is someone running
@@ -995,21 +998,20 @@ static void *
csched_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
void *dd)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched_unit *svc;
- /* Allocate per-VCPU info */
+ /* Allocate per-UNIT info */
svc = xzalloc(struct csched_unit);
if ( svc == NULL )
return NULL;
INIT_LIST_HEAD(&svc->runq_elem);
- INIT_LIST_HEAD(&svc->active_vcpu_elem);
+ INIT_LIST_HEAD(&svc->active_unit_elem);
svc->sdom = dd;
- svc->vcpu = vc;
- svc->pri = is_idle_domain(vc->domain) ?
+ svc->unit = unit;
+ svc->pri = is_idle_unit(unit) ?
CSCHED_PRI_IDLE : CSCHED_PRI_TS_UNDER;
- SCHED_VCPU_STATS_RESET(svc);
+ SCHED_UNIT_STATS_RESET(svc);
SCHED_STAT_CRANK(unit_alloc);
return svc;
}
@@ -1017,24 +1019,21 @@ csched_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
static void
csched_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched_unit *svc = unit->priv;
spinlock_t *lock;
- BUG_ON( is_idle_vcpu(vc) );
+ BUG_ON( is_idle_unit(unit) );
/* csched_res_pick() looks in vc->processor's runq, so we need the lock. */
lock = unit_schedule_lock_irq(unit);
- unit->res = csched_res_pick(ops, unit);
- vc->processor = unit->res->master_cpu;
+ sched_set_res(unit, csched_res_pick(ops, unit));
spin_unlock_irq(lock);
lock = unit_schedule_lock_irq(unit);
- if ( !__vcpu_on_runq(svc) && vcpu_runnable(vc) &&
- !vc->sched_unit->is_running )
+ if ( !__unit_on_runq(svc) && unit_runnable(unit) && !unit->is_running )
runq_insert(svc);
unit_schedule_unlock_irq(lock, unit);
@@ -1061,18 +1060,18 @@ csched_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
SCHED_STAT_CRANK(unit_remove);
- ASSERT(!__vcpu_on_runq(svc));
+ ASSERT(!__unit_on_runq(svc));
- if ( test_and_clear_bit(CSCHED_FLAG_VCPU_PARKED, &svc->flags) )
+ if ( test_and_clear_bit(CSCHED_FLAG_UNIT_PARKED, &svc->flags) )
{
SCHED_STAT_CRANK(unit_unpark);
- vcpu_unpause(svc->vcpu);
+ vcpu_unpause(svc->unit->vcpu_list);
}
spin_lock_irq(&prv->lock);
- if ( !list_empty(&svc->active_vcpu_elem) )
- __csched_vcpu_acct_stop_locked(prv, svc);
+ if ( !list_empty(&svc->active_unit_elem) )
+ __csched_unit_acct_stop_locked(prv, svc);
spin_unlock_irq(&prv->lock);
@@ -1082,86 +1081,85 @@ csched_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
static void
csched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched_unit * const svc = CSCHED_UNIT(unit);
- unsigned int cpu = vc->processor;
+ unsigned int cpu = sched_unit_cpu(unit);
SCHED_STAT_CRANK(unit_sleep);
- BUG_ON( is_idle_vcpu(vc) );
+ BUG_ON( is_idle_unit(unit) );
if ( curr_on_cpu(cpu) == unit )
{
/*
* We are about to tickle cpu, so we should clear its bit in idlers.
- * But, we are here because vc is going to sleep while running on cpu,
+ * But, we are here because unit is going to sleep while running on cpu,
* so the bit must be zero already.
*/
ASSERT(!cpumask_test_cpu(cpu, CSCHED_PRIV(per_cpu(scheduler, cpu))->idlers));
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
}
- else if ( __vcpu_on_runq(svc) )
+ else if ( __unit_on_runq(svc) )
runq_remove(svc);
}
static void
csched_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched_unit * const svc = CSCHED_UNIT(unit);
bool_t migrating;
- BUG_ON( is_idle_vcpu(vc) );
+ BUG_ON( is_idle_unit(unit) );
- if ( unlikely(curr_on_cpu(vc->processor) == unit) )
+ if ( unlikely(curr_on_cpu(sched_unit_cpu(unit)) == unit) )
{
SCHED_STAT_CRANK(unit_wake_running);
return;
}
- if ( unlikely(__vcpu_on_runq(svc)) )
+ if ( unlikely(__unit_on_runq(svc)) )
{
SCHED_STAT_CRANK(unit_wake_onrunq);
return;
}
- if ( likely(vcpu_runnable(vc)) )
+ if ( likely(unit_runnable(unit)) )
SCHED_STAT_CRANK(unit_wake_runnable);
else
SCHED_STAT_CRANK(unit_wake_not_runnable);
/*
- * We temporarly boost the priority of awaking VCPUs!
+ * We temporarily boost the priority of awaking UNITs!
*
- * If this VCPU consumes a non negligeable amount of CPU, it
+ * If this UNIT consumes a non negligible amount of CPU, it
* will eventually find itself in the credit accounting code
* path where its priority will be reset to normal.
*
- * If on the other hand the VCPU consumes little CPU and is
+ * If on the other hand the UNIT consumes little CPU and is
* blocking and awoken a lot (doing I/O for example), its
* priority will remain boosted, optimizing it's wake-to-run
* latencies.
*
- * This allows wake-to-run latency sensitive VCPUs to preempt
- * more CPU resource intensive VCPUs without impacting overall
+ * This allows wake-to-run latency sensitive UNITs to preempt
+ * more CPU resource intensive UNITs without impacting overall
* system fairness.
*
* There are two cases, when we don't want to boost:
- * - VCPUs that are waking up after a migration, rather than
+ * - UNITs that are waking up after a migration, rather than
* after having block;
- * - VCPUs of capped domains unpausing after earning credits
+ * - UNITs of capped domains unpausing after earning credits
* they had overspent.
*/
- migrating = test_and_clear_bit(CSCHED_FLAG_VCPU_MIGRATING, &svc->flags);
+ migrating = test_and_clear_bit(CSCHED_FLAG_UNIT_MIGRATING, &svc->flags);
if ( !migrating && svc->pri == CSCHED_PRI_TS_UNDER &&
- !test_bit(CSCHED_FLAG_VCPU_PARKED, &svc->flags) )
+ !test_bit(CSCHED_FLAG_UNIT_PARKED, &svc->flags) )
{
- TRACE_2D(TRC_CSCHED_BOOST_START, vc->domain->domain_id, vc->vcpu_id);
+ TRACE_2D(TRC_CSCHED_BOOST_START, unit->domain->domain_id,
+ unit->unit_id);
SCHED_STAT_CRANK(unit_boost);
svc->pri = CSCHED_PRI_TS_BOOST;
}
- /* Put the VCPU on the runq and tickle CPUs */
+ /* Put the UNIT on the runq and tickle CPUs */
runq_insert(svc);
__runq_tickle(svc);
}
@@ -1172,7 +1170,7 @@ csched_unit_yield(const struct scheduler *ops, struct sched_unit *unit)
struct csched_unit * const svc = CSCHED_UNIT(unit);
/* Let the scheduler know that this vcpu is trying to yield */
- set_bit(CSCHED_FLAG_VCPU_YIELD, &svc->flags);
+ set_bit(CSCHED_FLAG_UNIT_YIELD, &svc->flags);
}
static int
@@ -1201,8 +1199,8 @@ csched_dom_cntl(
{
if ( !list_empty(&sdom->active_sdom_elem) )
{
- prv->weight -= sdom->weight * sdom->active_vcpu_count;
- prv->weight += op->u.credit.weight * sdom->active_vcpu_count;
+ prv->weight -= sdom->weight * sdom->active_unit_count;
+ prv->weight += op->u.credit.weight * sdom->active_unit_count;
}
sdom->weight = op->u.credit.weight;
}
@@ -1231,9 +1229,9 @@ csched_aff_cntl(const struct scheduler *ops, struct sched_unit *unit,
/* Are we becoming exclusively pinned? */
if ( cpumask_weight(hard) == 1 )
- set_bit(CSCHED_FLAG_VCPU_PINNED, &svc->flags);
+ set_bit(CSCHED_FLAG_UNIT_PINNED, &svc->flags);
else
- clear_bit(CSCHED_FLAG_VCPU_PINNED, &svc->flags);
+ clear_bit(CSCHED_FLAG_UNIT_PINNED, &svc->flags);
}
static inline void
@@ -1276,14 +1274,14 @@ csched_sys_cntl(const struct scheduler *ops,
else if ( prv->ratelimit && !params->ratelimit_us )
printk(XENLOG_INFO "Disabling context switch rate limiting\n");
prv->ratelimit = MICROSECS(params->ratelimit_us);
- prv->vcpu_migr_delay = MICROSECS(params->vcpu_migr_delay_us);
+ prv->unit_migr_delay = MICROSECS(params->vcpu_migr_delay_us);
spin_unlock_irqrestore(&prv->lock, flags);
/* FALLTHRU */
case XEN_SYSCTL_SCHEDOP_getinfo:
params->tslice_ms = prv->tslice / MILLISECS(1);
params->ratelimit_us = prv->ratelimit / MICROSECS(1);
- params->vcpu_migr_delay_us = prv->vcpu_migr_delay / MICROSECS(1);
+ params->vcpu_migr_delay_us = prv->unit_migr_delay / MICROSECS(1);
rc = 0;
break;
}
@@ -1301,7 +1299,7 @@ csched_alloc_domdata(const struct scheduler *ops, struct domain *dom)
return ERR_PTR(-ENOMEM);
/* Initialize credit and weight */
- INIT_LIST_HEAD(&sdom->active_vcpu);
+ INIT_LIST_HEAD(&sdom->active_unit);
INIT_LIST_HEAD(&sdom->active_sdom_elem);
sdom->dom = dom;
sdom->weight = CSCHED_DEFAULT_WEIGHT;
@@ -1318,7 +1316,7 @@ csched_free_domdata(const struct scheduler *ops, void *data)
/*
* This is a O(n) optimized sort of the runq.
*
- * Time-share VCPUs can only be one of two priorities, UNDER or OVER. We walk
+ * Time-share UNITs can only be one of two priorities, UNDER or OVER. We walk
* through the runq and move up any UNDERs that are preceded by OVERS. We
* remember the last UNDER to make the move up operation O(1).
*/
@@ -1371,7 +1369,7 @@ csched_acct(void* dummy)
{
struct csched_private *prv = dummy;
unsigned long flags;
- struct list_head *iter_vcpu, *next_vcpu;
+ struct list_head *iter_unit, *next_unit;
struct list_head *iter_sdom, *next_sdom;
struct csched_unit *svc;
struct csched_dom *sdom;
@@ -1418,26 +1416,26 @@ csched_acct(void* dummy)
sdom = list_entry(iter_sdom, struct csched_dom, active_sdom_elem);
BUG_ON( is_idle_domain(sdom->dom) );
- BUG_ON( sdom->active_vcpu_count == 0 );
+ BUG_ON( sdom->active_unit_count == 0 );
BUG_ON( sdom->weight == 0 );
- BUG_ON( (sdom->weight * sdom->active_vcpu_count) > weight_left );
+ BUG_ON( (sdom->weight * sdom->active_unit_count) > weight_left );
- weight_left -= ( sdom->weight * sdom->active_vcpu_count );
+ weight_left -= ( sdom->weight * sdom->active_unit_count );
/*
* A domain's fair share is computed using its weight in competition
* with that of all other active domains.
*
- * At most, a domain can use credits to run all its active VCPUs
+ * At most, a domain can use credits to run all its active UNITs
* for one full accounting period. We allow a domain to earn more
* only when the system-wide credit balance is negative.
*/
- credit_peak = sdom->active_vcpu_count * prv->credits_per_tslice;
+ credit_peak = sdom->active_unit_count * prv->credits_per_tslice;
if ( prv->credit_balance < 0 )
{
credit_peak += ( ( -prv->credit_balance
* sdom->weight
- * sdom->active_vcpu_count) +
+ * sdom->active_unit_count) +
(weight_total - 1)
) / weight_total;
}
@@ -1448,14 +1446,14 @@ csched_acct(void* dummy)
if ( credit_cap < credit_peak )
credit_peak = credit_cap;
- /* FIXME -- set cap per-vcpu as well...? */
- credit_cap = ( credit_cap + ( sdom->active_vcpu_count - 1 )
- ) / sdom->active_vcpu_count;
+ /* FIXME -- set cap per-unit as well...? */
+ credit_cap = ( credit_cap + ( sdom->active_unit_count - 1 )
+ ) / sdom->active_unit_count;
}
credit_fair = ( ( credit_total
* sdom->weight
- * sdom->active_vcpu_count )
+ * sdom->active_unit_count )
+ (weight_total - 1)
) / weight_total;
@@ -1489,14 +1487,14 @@ csched_acct(void* dummy)
credit_fair = credit_peak;
}
- /* Compute fair share per VCPU */
- credit_fair = ( credit_fair + ( sdom->active_vcpu_count - 1 )
- ) / sdom->active_vcpu_count;
+ /* Compute fair share per UNIT */
+ credit_fair = ( credit_fair + ( sdom->active_unit_count - 1 )
+ ) / sdom->active_unit_count;
- list_for_each_safe( iter_vcpu, next_vcpu, &sdom->active_vcpu )
+ list_for_each_safe( iter_unit, next_unit, &sdom->active_unit )
{
- svc = list_entry(iter_vcpu, struct csched_unit, active_vcpu_elem);
+ svc = list_entry(iter_unit, struct csched_unit, active_unit_elem);
BUG_ON( sdom != svc->sdom );
/* Increment credit */
@@ -1504,20 +1502,20 @@ csched_acct(void* dummy)
credit = atomic_read(&svc->credit);
/*
- * Recompute priority or, if VCPU is idling, remove it from
+ * Recompute priority or, if UNIT is idling, remove it from
* the active list.
*/
if ( credit < 0 )
{
svc->pri = CSCHED_PRI_TS_OVER;
- /* Park running VCPUs of capped-out domains */
+ /* Park running UNITs of capped-out domains */
if ( sdom->cap != 0U &&
credit < -credit_cap &&
- !test_and_set_bit(CSCHED_FLAG_VCPU_PARKED, &svc->flags) )
+ !test_and_set_bit(CSCHED_FLAG_UNIT_PARKED, &svc->flags) )
{
SCHED_STAT_CRANK(unit_park);
- vcpu_pause_nosync(svc->vcpu);
+ vcpu_pause_nosync(svc->unit->vcpu_list);
}
/* Lower bound on credits */
@@ -1533,22 +1531,22 @@ csched_acct(void* dummy)
svc->pri = CSCHED_PRI_TS_UNDER;
/* Unpark any capped domains whose credits go positive */
- if ( test_bit(CSCHED_FLAG_VCPU_PARKED, &svc->flags) )
+ if ( test_bit(CSCHED_FLAG_UNIT_PARKED, &svc->flags) )
{
/*
* It's important to unset the flag AFTER the unpause()
- * call to make sure the VCPU's priority is not boosted
+ * call to make sure the UNIT's priority is not boosted
* if it is woken up here.
*/
SCHED_STAT_CRANK(unit_unpark);
- vcpu_unpause(svc->vcpu);
- clear_bit(CSCHED_FLAG_VCPU_PARKED, &svc->flags);
+ vcpu_unpause(svc->unit->vcpu_list);
+ clear_bit(CSCHED_FLAG_UNIT_PARKED, &svc->flags);
}
- /* Upper bound on credits means VCPU stops earning */
+ /* Upper bound on credits means UNIT stops earning */
if ( credit > prv->credits_per_tslice )
{
- __csched_vcpu_acct_stop_locked(prv, svc);
+ __csched_unit_acct_stop_locked(prv, svc);
/* Divide credits in half, so that when it starts
* accounting again, it starts a little bit "ahead" */
credit /= 2;
@@ -1556,8 +1554,8 @@ csched_acct(void* dummy)
}
}
- SCHED_VCPU_STAT_SET(svc, credit_last, credit);
- SCHED_VCPU_STAT_SET(svc, credit_incr, credit_fair);
+ SCHED_UNIT_STAT_SET(svc, credit_last, credit);
+ SCHED_UNIT_STAT_SET(svc, credit_incr, credit_fair);
credit_balance += credit;
}
}
@@ -1583,10 +1581,10 @@ csched_tick(void *_cpu)
spc->tick++;
/*
- * Accounting for running VCPU
+ * Accounting for running UNIT
*/
- if ( !is_idle_vcpu(current) )
- csched_vcpu_acct(prv, cpu);
+ if ( !is_idle_unit(current->sched_unit) )
+ csched_unit_acct(prv, cpu);
/*
* Check if runq needs to be sorted
@@ -1607,7 +1605,7 @@ csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
const struct csched_pcpu * const peer_pcpu = CSCHED_PCPU(peer_cpu);
struct csched_unit *speer;
struct list_head *iter;
- struct vcpu *vc;
+ struct sched_unit *unit;
ASSERT(peer_pcpu != NULL);
@@ -1615,7 +1613,7 @@ csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
* Don't steal from an idle CPU's runq because it's about to
* pick up work from it itself.
*/
- if ( unlikely(is_idle_vcpu(curr_on_cpu(peer_cpu)->vcpu_list)) )
+ if ( unlikely(is_idle_unit(curr_on_cpu(peer_cpu))) )
goto out;
list_for_each( iter, &peer_pcpu->runq )
@@ -1623,46 +1621,44 @@ csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
speer = __runq_elem(iter);
/*
- * If next available VCPU here is not of strictly higher
+ * If next available UNIT here is not of strictly higher
* priority than ours, this PCPU is useless to us.
*/
if ( speer->pri <= pri )
break;
- /* Is this VCPU runnable on our PCPU? */
- vc = speer->vcpu;
- BUG_ON( is_idle_vcpu(vc) );
+ /* Is this UNIT runnable on our PCPU? */
+ unit = speer->unit;
+ BUG_ON( is_idle_unit(unit) );
/*
- * If the vcpu is still in peer_cpu's scheduling tail, or if it
+ * If the unit is still in peer_cpu's scheduling tail, or if it
* has no useful soft affinity, skip it.
*
* In fact, what we want is to check if we have any "soft-affine
* work" to steal, before starting to look at "hard-affine work".
*
- * Notice that, if not even one vCPU on this runq has a useful
+ * Notice that, if not even one unit on this runq has a useful
* soft affinity, we could have avoid considering this runq for
* a soft balancing step in the first place. This, for instance,
* can be implemented by taking note of on what runq there are
- * vCPUs with useful soft affinities in some sort of bitmap
+ * units with useful soft affinities in some sort of bitmap
* or counter.
*/
- if ( vc->sched_unit->is_running ||
- (balance_step == BALANCE_SOFT_AFFINITY &&
- !has_soft_affinity(vc->sched_unit)) )
+ if ( unit->is_running || (balance_step == BALANCE_SOFT_AFFINITY &&
+ !has_soft_affinity(unit)) )
continue;
- affinity_balance_cpumask(vc->sched_unit, balance_step, cpumask_scratch);
- if ( __csched_vcpu_is_migrateable(prv, vc, cpu, cpumask_scratch) )
+ affinity_balance_cpumask(unit, balance_step, cpumask_scratch);
+ if ( __csched_unit_is_migrateable(prv, unit, cpu, cpumask_scratch) )
{
/* We got a candidate. Grab it! */
- TRACE_3D(TRC_CSCHED_STOLEN_VCPU, peer_cpu,
- vc->domain->domain_id, vc->vcpu_id);
- SCHED_VCPU_STAT_CRANK(speer, migrate_q);
+ TRACE_3D(TRC_CSCHED_STOLEN_UNIT, peer_cpu,
+ unit->domain->domain_id, unit->unit_id);
+ SCHED_UNIT_STAT_CRANK(speer, migrate_q);
SCHED_STAT_CRANK(migrate_queued);
- WARN_ON(vc->is_urgent);
runq_remove(speer);
- sched_set_res(vc->sched_unit, get_sched_res(cpu));
+ sched_set_res(unit, get_sched_res(cpu));
/*
* speer will start executing directly on cpu, without having to
* go through runq_insert(). So we must update the runnable count
@@ -1688,7 +1684,7 @@ csched_load_balance(struct csched_private *prv, int cpu,
int peer_cpu, first_cpu, peer_node, bstep;
int node = cpu_to_node(cpu);
- BUG_ON( cpu != snext->vcpu->processor );
+ BUG_ON( cpu != sched_unit_cpu(snext->unit) );
online = cpupool_online_cpumask(c);
/*
@@ -1717,7 +1713,7 @@ csched_load_balance(struct csched_private *prv, int cpu,
/*
* We peek at the non-idling CPUs in a node-wise fashion. In fact,
* it is more likely that we find some affine work on our same
- * node, not to mention that migrating vcpus within the same node
+ * node, not to mention that migrating units within the same node
* could well expected to be cheaper than across-nodes (memory
* stays local, there might be some node-wide cache[s], etc.).
*/
@@ -1738,7 +1734,7 @@ csched_load_balance(struct csched_private *prv, int cpu,
spinlock_t *lock;
/*
- * If there is only one runnable vCPU on peer_cpu, it means
+ * If there is only one runnable unit on peer_cpu, it means
* there's no one to be stolen in its runqueue, so skip it.
*
* Checking this without holding the lock is racy... But that's
@@ -1751,13 +1747,13 @@ csched_load_balance(struct csched_private *prv, int cpu,
* And we can avoid that by re-checking nr_runnable after
* having grabbed the lock, if we want;
* - if we race with inc_nr_runnable(), we skip a pCPU that may
- * have runnable vCPUs in its runqueue, but that's not a
+ * have runnable units in its runqueue, but that's not a
* problem because:
* + if racing with csched_unit_insert() or csched_unit_wake(),
- * __runq_tickle() will be called afterwords, so the vCPU
+ * __runq_tickle() will be called afterwords, so the unit
* won't get stuck in the runqueue for too long;
- * + if racing with csched_runq_steal(), it may be that a
- * vCPU that we could have picked up, stays in a runqueue
+ * + if racing with csched_runq_steal(), it may be that an
+ * unit that we could have picked up, stays in a runqueue
* until someone else tries to steal it again. But this is
* no worse than what can happen already (without this
* optimization), it the pCPU would schedule right after we
@@ -1792,7 +1788,7 @@ csched_load_balance(struct csched_private *prv, int cpu,
csched_runq_steal(peer_cpu, cpu, snext->pri, bstep) : NULL;
pcpu_schedule_unlock(lock, peer_cpu);
- /* As soon as one vcpu is found, balancing ends */
+ /* As soon as one unit is found, balancing ends */
if ( speer != NULL )
{
*stolen = 1;
@@ -1831,14 +1827,15 @@ csched_schedule(
{
const int cpu = smp_processor_id();
struct list_head * const runq = RUNQ(cpu);
- struct csched_unit * const scurr = CSCHED_UNIT(current->sched_unit);
+ struct sched_unit *unit = current->sched_unit;
+ struct csched_unit * const scurr = CSCHED_UNIT(unit);
struct csched_private *prv = CSCHED_PRIV(ops);
struct csched_unit *snext;
struct task_slice ret;
s_time_t runtime, tslice;
SCHED_STAT_CRANK(schedule);
- CSCHED_VCPU_CHECK(current);
+ CSCHED_UNIT_CHECK(unit);
/*
* Here in Credit1 code, we usually just call TRACE_nD() helpers, and
@@ -1852,31 +1849,31 @@ csched_schedule(
} d;
d.cpu = cpu;
d.tasklet = tasklet_work_scheduled;
- d.idle = is_idle_vcpu(current);
+ d.idle = is_idle_unit(unit);
__trace_var(TRC_CSCHED_SCHEDULE, 1, sizeof(d),
(unsigned char *)&d);
}
- runtime = now - current->sched_unit->state_entry_time;
+ runtime = now - unit->state_entry_time;
if ( runtime < 0 ) /* Does this ever happen? */
runtime = 0;
- if ( !is_idle_vcpu(scurr->vcpu) )
+ if ( !is_idle_unit(unit) )
{
- /* Update credits of a non-idle VCPU. */
+ /* Update credits of a non-idle UNIT. */
burn_credits(scurr, now);
scurr->start_time -= now;
scurr->last_sched_time = now;
}
else
{
- /* Re-instate a boosted idle VCPU as normal-idle. */
+ /* Re-instate a boosted idle UNIT as normal-idle. */
scurr->pri = CSCHED_PRI_IDLE;
}
/* Choices, choices:
- * - If we have a tasklet, we need to run the idle vcpu no matter what.
- * - If sched rate limiting is in effect, and the current vcpu has
+ * - If we have a tasklet, we need to run the idle unit no matter what.
+ * - If sched rate limiting is in effect, and the current unit has
* run for less than that amount of time, continue the current one,
* but with a shorter timeslice and return it immediately
* - Otherwise, chose the one with the highest priority (which may
@@ -1894,11 +1891,11 @@ csched_schedule(
* In fact, it may be the case that scurr is about to spin, and there's
* no point forcing it to do so until rate limiting expires.
*/
- if ( !test_bit(CSCHED_FLAG_VCPU_YIELD, &scurr->flags)
+ if ( !test_bit(CSCHED_FLAG_UNIT_YIELD, &scurr->flags)
&& !tasklet_work_scheduled
&& prv->ratelimit
- && vcpu_runnable(current)
- && !is_idle_vcpu(current)
+ && unit_runnable(unit)
+ && !is_idle_unit(unit)
&& runtime < prv->ratelimit )
{
snext = scurr;
@@ -1916,11 +1913,11 @@ csched_schedule(
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
unsigned runtime;
} d;
- d.dom = scurr->vcpu->domain->domain_id;
- d.vcpu = scurr->vcpu->vcpu_id;
+ d.dom = unit->domain->domain_id;
+ d.unit = unit->unit_id;
d.runtime = runtime;
__trace_var(TRC_CSCHED_RATELIMIT, 1, sizeof(d),
(unsigned char *)&d);
@@ -1932,13 +1929,13 @@ csched_schedule(
tslice = prv->tslice;
/*
- * Select next runnable local VCPU (ie top of local runq)
+ * Select next runnable local UNIT (ie top of local runq)
*/
- if ( vcpu_runnable(current) )
+ if ( unit_runnable(unit) )
__runq_insert(scurr);
else
{
- BUG_ON( is_idle_vcpu(current) || list_empty(runq) );
+ BUG_ON( is_idle_unit(unit) || list_empty(runq) );
/* Current has blocked. Update the runnable counter for this cpu. */
dec_nr_runnable(cpu);
}
@@ -1946,23 +1943,23 @@ csched_schedule(
snext = __runq_elem(runq->next);
ret.migrated = 0;
- /* Tasklet work (which runs in idle VCPU context) overrides all else. */
+ /* Tasklet work (which runs in idle UNIT context) overrides all else. */
if ( tasklet_work_scheduled )
{
TRACE_0D(TRC_CSCHED_SCHED_TASKLET);
- snext = CSCHED_UNIT(idle_vcpu[cpu]->sched_unit);
+ snext = CSCHED_UNIT(sched_idle_unit(cpu));
snext->pri = CSCHED_PRI_TS_BOOST;
}
/*
* Clear YIELD flag before scheduling out
*/
- clear_bit(CSCHED_FLAG_VCPU_YIELD, &scurr->flags);
+ clear_bit(CSCHED_FLAG_UNIT_YIELD, &scurr->flags);
/*
* SMP Load balance:
*
- * If the next highest priority local runnable VCPU has already eaten
+ * If the next highest priority local runnable UNIT has already eaten
* through its credits, look on other PCPUs to see if we have more
* urgent work... If not, csched_load_balance() will return snext, but
* already removed from the runq.
@@ -1986,32 +1983,32 @@ csched_schedule(
cpumask_clear_cpu(cpu, prv->idlers);
}
- if ( !is_idle_vcpu(snext->vcpu) )
+ if ( !is_idle_unit(snext->unit) )
snext->start_time += now;
out:
/*
* Return task to run next...
*/
- ret.time = (is_idle_vcpu(snext->vcpu) ?
+ ret.time = (is_idle_unit(snext->unit) ?
-1 : tslice);
- ret.task = snext->vcpu->sched_unit;
+ ret.task = snext->unit;
- CSCHED_VCPU_CHECK(ret.task->vcpu_list);
+ CSCHED_UNIT_CHECK(ret.task);
return ret;
}
static void
-csched_dump_vcpu(struct csched_unit *svc)
+csched_dump_unit(struct csched_unit *svc)
{
struct csched_dom * const sdom = svc->sdom;
printk("[%i.%i] pri=%i flags=%x cpu=%i",
- svc->vcpu->domain->domain_id,
- svc->vcpu->vcpu_id,
+ svc->unit->domain->domain_id,
+ svc->unit->unit_id,
svc->pri,
svc->flags,
- svc->vcpu->processor);
+ sched_unit_cpu(svc->unit));
if ( sdom )
{
@@ -2045,7 +2042,7 @@ csched_dump_pcpu(const struct scheduler *ops, int cpu)
/*
* We need both locks:
- * - csched_dump_vcpu() wants to access domains' scheduling
+ * - csched_dump_unit() wants to access domains' scheduling
* parameters, which are protected by the private scheduler lock;
* - we scan through the runqueue, so we need the proper runqueue
* lock (the one of the runqueue of this cpu).
@@ -2061,12 +2058,12 @@ csched_dump_pcpu(const struct scheduler *ops, int cpu)
CPUMASK_PR(per_cpu(cpu_sibling_mask, cpu)),
CPUMASK_PR(per_cpu(cpu_core_mask, cpu)));
- /* current VCPU (nothing to say if that's the idle vcpu). */
+ /* current UNIT (nothing to say if that's the idle unit). */
svc = CSCHED_UNIT(curr_on_cpu(cpu));
- if ( svc && !is_idle_vcpu(svc->vcpu) )
+ if ( svc && !is_idle_unit(svc->unit) )
{
printk("\trun: ");
- csched_dump_vcpu(svc);
+ csched_dump_unit(svc);
}
loop = 0;
@@ -2076,7 +2073,7 @@ csched_dump_pcpu(const struct scheduler *ops, int cpu)
if ( svc )
{
printk("\t%3d: ", ++loop);
- csched_dump_vcpu(svc);
+ csched_dump_unit(svc);
}
}
@@ -2118,29 +2115,29 @@ csched_dump(const struct scheduler *ops)
prv->ratelimit / MICROSECS(1),
CSCHED_CREDITS_PER_MSEC,
prv->ticks_per_tslice,
- prv->vcpu_migr_delay/ MICROSECS(1));
+ prv->unit_migr_delay/ MICROSECS(1));
printk("idlers: %*pb\n", CPUMASK_PR(prv->idlers));
- printk("active vcpus:\n");
+ printk("active units:\n");
loop = 0;
list_for_each( iter_sdom, &prv->active_sdom )
{
struct csched_dom *sdom;
sdom = list_entry(iter_sdom, struct csched_dom, active_sdom_elem);
- list_for_each( iter_svc, &sdom->active_vcpu )
+ list_for_each( iter_svc, &sdom->active_unit )
{
struct csched_unit *svc;
spinlock_t *lock;
- svc = list_entry(iter_svc, struct csched_unit, active_vcpu_elem);
- lock = unit_schedule_lock(svc->vcpu->sched_unit);
+ svc = list_entry(iter_svc, struct csched_unit, active_unit_elem);
+ lock = unit_schedule_lock(svc->unit);
printk("\t%3d: ", ++loop);
- csched_dump_vcpu(svc);
+ csched_dump_unit(svc);
- unit_schedule_unlock(lock, svc->vcpu->sched_unit);
+ unit_schedule_unlock(lock, svc->unit);
}
}
@@ -2214,7 +2211,7 @@ csched_init(struct scheduler *ops)
else
prv->ratelimit = MICROSECS(sched_ratelimit_us);
- prv->vcpu_migr_delay = MICROSECS(vcpu_migration_delay_us);
+ prv->unit_migr_delay = MICROSECS(vcpu_migration_delay_us);
return 0;
}
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 17/47] xen/sched: make credit2 scheduler vcpu agnostic.
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (15 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 16/47] xen/sched: make credit " Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-25 15:02 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 18/47] xen/sched: make arinc653 " Juergen Gross
` (31 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Dario Faggioli
Switch credit2 scheduler completely from vcpu to sched_unit usage.
As we are touching lots of lines remove some white space at the end of
the line, too.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/sched_credit2.c | 820 ++++++++++++++++++++++-----------------------
1 file changed, 403 insertions(+), 417 deletions(-)
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index a6083289f6..0d1ba97dbc 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -45,7 +45,7 @@
#define TRC_CSCHED2_SCHED_TASKLET TRC_SCHED_CLASS_EVT(CSCHED2, 8)
#define TRC_CSCHED2_UPDATE_LOAD TRC_SCHED_CLASS_EVT(CSCHED2, 9)
#define TRC_CSCHED2_RUNQ_ASSIGN TRC_SCHED_CLASS_EVT(CSCHED2, 10)
-#define TRC_CSCHED2_UPDATE_VCPU_LOAD TRC_SCHED_CLASS_EVT(CSCHED2, 11)
+#define TRC_CSCHED2_UPDATE_UNIT_LOAD TRC_SCHED_CLASS_EVT(CSCHED2, 11)
#define TRC_CSCHED2_UPDATE_RUNQ_LOAD TRC_SCHED_CLASS_EVT(CSCHED2, 12)
#define TRC_CSCHED2_TICKLE_NEW TRC_SCHED_CLASS_EVT(CSCHED2, 13)
#define TRC_CSCHED2_RUNQ_MAX_WEIGHT TRC_SCHED_CLASS_EVT(CSCHED2, 14)
@@ -74,13 +74,13 @@
* Design:
*
* VMs "burn" credits based on their weight; higher weight means
- * credits burn more slowly. The highest weight vcpu burns credits at
+ * credits burn more slowly. The highest weight unit burns credits at
* a rate of 1 credit per nanosecond. Others burn proportionally
* more.
*
- * vcpus are inserted into the runqueue by credit order.
+ * units are inserted into the runqueue by credit order.
*
- * Credits are "reset" when the next vcpu in the runqueue is less than
+ * Credits are "reset" when the next unit in the runqueue is less than
* or equal to zero. At that point, everyone's credits are "clipped"
* to a small value, and a fixed credit is added to everyone.
*/
@@ -95,33 +95,33 @@
* be given a cap of 25%; a domain that must not use more than 1+1/2 of
* physical CPU time, will be given a cap of 150%;
*
- * - caps are per-domain (not per-vCPU). If a domain has only 1 vCPU, and
- * a 40% cap, that one vCPU will use 40% of one pCPU. If a somain has 4
- * vCPUs, and a 200% cap, the equivalent of 100% time on 2 pCPUs will be
- * split among the v vCPUs. How much each of the vCPUs will actually get,
+ * - caps are per-domain (not per-unit). If a domain has only 1 unit, and
+ * a 40% cap, that one unit will use 40% of one pCPU. If a somain has 4
+ * units, and a 200% cap, the equivalent of 100% time on 2 pCPUs will be
+ * split among the v units. How much each of the units will actually get,
* during any given interval of time, is unspecified (as it depends on
* various aspects: workload, system load, etc.). For instance, it is
- * possible that, during a given time interval, 2 vCPUs use 100% each,
+ * possible that, during a given time interval, 2 units use 100% each,
* and the other two use nothing; while during another time interval,
- * two vCPUs use 80%, one uses 10% and the other 30%; or that each use
+ * two units use 80%, one uses 10% and the other 30%; or that each use
* 50% (and so on and so forth).
*
* For implementing this, we use the following approach:
*
* - each domain is given a 'budget', an each domain has a timer, which
* replenishes the domain's budget periodically. The budget is the amount
- * of time the vCPUs of the domain can use every 'period';
+ * of time the units of the domain can use every 'period';
*
* - the period is CSCHED2_BDGT_REPL_PERIOD, and is the same for all domains
* (but each domain has its own timer; so the all are periodic by the same
* period, but replenishment of the budgets of the various domains, at
* periods boundaries, are not synchronous);
*
- * - when vCPUs run, they consume budget. When they don't run, they don't
- * consume budget. If there is no budget left for the domain, no vCPU of
- * that domain can run. If a vCPU tries to run and finds that there is no
+ * - when units run, they consume budget. When they don't run, they don't
+ * consume budget. If there is no budget left for the domain, no unit of
+ * that domain can run. If an unit tries to run and finds that there is no
* budget, it blocks.
- * At whatever time a vCPU wants to run, it must check the domain's budget,
+ * At whatever time an unit wants to run, it must check the domain's budget,
* and if there is some, it can use it.
*
* - budget is replenished to the top of the capacity for the domain once
@@ -129,39 +129,39 @@
* though, the budget after a replenishment will always be at most equal
* to the total capacify of the domain ('tot_budget');
*
- * - when a budget replenishment occurs, if there are vCPUs that had been
+ * - when a budget replenishment occurs, if there are units that had been
* blocked because of lack of budget, they'll be unblocked, and they will
* (potentially) be able to run again.
*
* Finally, some even more implementation related detail:
*
- * - budget is stored in a domain-wide pool. vCPUs of the domain that want
+ * - budget is stored in a domain-wide pool. Items of the domain that want
* to run go to such pool, and grub some. When they do so, the amount
* they grabbed is _immediately_ removed from the pool. This happens in
- * vcpu_grab_budget();
+ * unit_grab_budget();
*
- * - when vCPUs stop running, if they've not consumed all the budget they
+ * - when units stop running, if they've not consumed all the budget they
* took, the leftover is put back in the pool. This happens in
- * vcpu_return_budget();
+ * unit_return_budget();
*
- * - the above means that a vCPU can find out that there is no budget and
+ * - the above means that an unit can find out that there is no budget and
* block, not only if the cap has actually been reached (for this period),
- * but also if some other vCPUs, in order to run, have grabbed a certain
+ * but also if some other units, in order to run, have grabbed a certain
* quota of budget, no matter whether they've already used it all or not.
- * A vCPU blocking because (any form of) lack of budget is said to be
- * "parked", and such blocking happens in park_vcpu();
+ * An unit blocking because (any form of) lack of budget is said to be
+ * "parked", and such blocking happens in park_unit();
*
- * - when a vCPU stops running, and puts back some budget in the domain pool,
+ * - when an unit stops running, and puts back some budget in the domain pool,
* we need to check whether there is someone which has been parked and that
- * can be unparked. This happens in unpark_parked_vcpus(), called from
+ * can be unparked. This happens in unpark_parked_units(), called from
* csched2_context_saved();
*
* - of course, unparking happens also as a consequence of the domain's budget
* being replenished by the periodic timer. This also occurs by means of
* calling csched2_context_saved() (but from replenish_domain_budget());
*
- * - parked vCPUs of a domain are kept in a (per-domain) list, called
- * 'parked_vcpus'). Manipulation of the list and of the domain-wide budget
+ * - parked units of a domain are kept in a (per-domain) list, called
+ * 'parked_units'). Manipulation of the list and of the domain-wide budget
* pool, must occur only when holding the 'budget_lock'.
*/
@@ -174,9 +174,9 @@
* pcpu_schedule_lock() / unit_schedule_lock() (and friends),
* * a cpu may (try to) take a "remote" runqueue lock, e.g., for
* load balancing;
- * + serializes runqueue operations (removing and inserting vcpus);
+ * + serializes runqueue operations (removing and inserting units);
* + protects runqueue-wide data in csched2_runqueue_data;
- * + protects vcpu parameters in csched2_unit for the vcpu in the
+ * + protects unit parameters in csched2_unit for the unit in the
* runqueue.
*
* - Private scheduler lock
@@ -190,8 +190,8 @@
* + it is per-domain;
* + protects, in domains that have an utilization cap;
* * manipulation of the total budget of the domain (as it is shared
- * among all vCPUs of the domain),
- * * manipulation of the list of vCPUs that are blocked waiting for
+ * among all units of the domain),
+ * * manipulation of the list of units that are blocked waiting for
* some budget to be available.
*
* - Type:
@@ -228,9 +228,9 @@
*/
#define CSCHED2_CREDIT_INIT MILLISECS(10)
/*
- * Amount of credit the idle vcpus have. It never changes, as idle
- * vcpus does not consume credits, and it must be lower than whatever
- * amount of credit 'regular' vcpu would end up with.
+ * Amount of credit the idle units have. It never changes, as idle
+ * units does not consume credits, and it must be lower than whatever
+ * amount of credit 'regular' unit would end up with.
*/
#define CSCHED2_IDLE_CREDIT (-(1U<<30))
/*
@@ -243,9 +243,9 @@
* MIN_TIMER.
*/
#define CSCHED2_MIGRATE_RESIST ((opt_migrate_resist)*MICROSECS(1))
-/* How much to "compensate" a vcpu for L2 migration. */
+/* How much to "compensate" an unit for L2 migration. */
#define CSCHED2_MIGRATE_COMPENSATION MICROSECS(50)
-/* How tolerant we should be when peeking at runtime of vcpus on other cpus */
+/* How tolerant we should be when peeking at runtime of units on other cpus */
#define CSCHED2_RATELIMIT_TICKLE_TOLERANCE MICROSECS(50)
/* Reset: Value below which credit will be reset. */
#define CSCHED2_CREDIT_RESET 0
@@ -258,7 +258,7 @@
* Flags
*/
/*
- * CSFLAG_scheduled: Is this vcpu either running on, or context-switching off,
+ * CSFLAG_scheduled: Is this unit either running on, or context-switching off,
* a physical cpu?
* + Accessed only with runqueue lock held
* + Set when chosen as next in csched2_schedule().
@@ -280,21 +280,21 @@
#define __CSFLAG_delayed_runq_add 2
#define CSFLAG_delayed_runq_add (1U<<__CSFLAG_delayed_runq_add)
/*
- * CSFLAG_runq_migrate_request: This vcpu is being migrated as a result of a
+ * CSFLAG_runq_migrate_request: This unit is being migrated as a result of a
* credit2-initiated runq migrate request; migrate it to the runqueue indicated
- * in the svc struct.
+ * in the svc struct.
*/
#define __CSFLAG_runq_migrate_request 3
#define CSFLAG_runq_migrate_request (1U<<__CSFLAG_runq_migrate_request)
/*
- * CSFLAG_vcpu_yield: this vcpu was running, and has called vcpu_yield(). The
+ * CSFLAG_unit_yield: this unit was running, and has called vcpu_yield(). The
* scheduler is invoked to see if we can give the cpu to someone else, and
- * get back to the yielding vcpu in a while.
+ * get back to the yielding unit in a while.
*/
-#define __CSFLAG_vcpu_yield 4
-#define CSFLAG_vcpu_yield (1U<<__CSFLAG_vcpu_yield)
+#define __CSFLAG_unit_yield 4
+#define CSFLAG_unit_yield (1U<<__CSFLAG_unit_yield)
/*
- * CSFLAGS_pinned: this vcpu is currently 'pinned', i.e., has its hard
+ * CSFLAGS_pinned: this unit is currently 'pinned', i.e., has its hard
* affinity set to one and only 1 cpu (and, hence, can only run there).
*/
#define __CSFLAG_pinned 5
@@ -306,7 +306,7 @@ integer_param("sched_credit2_migrate_resist", opt_migrate_resist);
/*
* Load tracking and load balancing
*
- * Load history of runqueues and vcpus is accounted for by using an
+ * Load history of runqueues and units is accounted for by using an
* exponential weighted moving average algorithm. However, instead of using
* fractions,we shift everything to left by the number of bits we want to
* use for representing the fractional part (Q-format).
@@ -326,7 +326,7 @@ integer_param("sched_credit2_migrate_resist", opt_migrate_resist);
*
* where W is the length of the window, P the multiplier for transitiong into
* Q-format fixed point arithmetic and load is the instantaneous load of a
- * runqueue, which basically is the number of runnable vcpus there are on the
+ * runqueue, which basically is the number of runnable units there are on the
* runqueue (for the meaning of the other terms, look at the doc comment to
* update_runq_load()).
*
@@ -338,7 +338,7 @@ integer_param("sched_credit2_migrate_resist", opt_migrate_resist);
* The maximum possible value for the average load, which we want to store in
* s_time_t type variables (i.e., we have 63 bits available) is load*P. This
* means that, with P 18 bits wide, load can occupy 45 bits. This in turn
- * means we can have 2^45 vcpus in each runqueue, before overflow occurs!
+ * means we can have 2^45 units in each runqueue, before overflow occurs!
*
* However, it can happen that, at step j+1, if:
*
@@ -354,13 +354,13 @@ integer_param("sched_credit2_migrate_resist", opt_migrate_resist);
*
* 2^(63 - 30 - 18) = 2^15 = 32768
*
- * So 32768 is the maximum number of vcpus the we can have in a runqueue,
+ * So 32768 is the maximum number of units the we can have in a runqueue,
* at any given time, and still not have problems with the load tracking
* calculations... and this is more than fine.
*
* As a matter of fact, since we are using microseconds granularity, we have
* W=2^20. So, still with 18 fractional bits and a 1 second long window, there
- * may be 2^25 = 33554432 vcpus in a runq before we have to start thinking
+ * may be 2^25 = 33554432 units in a runq before we have to start thinking
* about overflow.
*/
@@ -469,7 +469,7 @@ struct csched2_runqueue_data {
unsigned int nr_cpus; /* How many CPUs are sharing this runqueue */
int id; /* ID of this runqueue (-1 if invalid) */
- int load; /* Instantaneous load (num of non-idle vcpus) */
+ int load; /* Instantaneous load (num of non-idle units) */
s_time_t load_last_update; /* Last time average was updated */
s_time_t avgload; /* Decaying queue load */
s_time_t b_avgload; /* Decaying queue load modified by balancing */
@@ -479,8 +479,8 @@ struct csched2_runqueue_data {
tickled, /* Have been asked to go through schedule */
idle; /* Currently idle pcpus */
- struct list_head svc; /* List of all vcpus assigned to the runqueue */
- unsigned int max_weight; /* Max weight of the vcpus in this runqueue */
+ struct list_head svc; /* List of all units assigned to the runqueue */
+ unsigned int max_weight; /* Max weight of the units in this runqueue */
unsigned int pick_bias; /* Last picked pcpu. Start from it next time */
};
@@ -510,20 +510,20 @@ struct csched2_pcpu {
};
/*
- * Virtual CPU
+ * Schedule Item
*/
struct csched2_unit {
struct csched2_dom *sdom; /* Up-pointer to domain */
- struct vcpu *vcpu; /* Up-pointer, to vcpu */
+ struct sched_unit *unit; /* Up-pointer, to schedule unit */
struct csched2_runqueue_data *rqd; /* Up-pointer to the runqueue */
int credit; /* Current amount of credit */
- unsigned int weight; /* Weight of this vcpu */
+ unsigned int weight; /* Weight of this unit */
unsigned int residual; /* Reminder of div(max_weight/weight) */
unsigned flags; /* Status flags (16 bits would be ok, */
s_time_t budget; /* Current budget (if domains has cap) */
/* but clear_bit() does not like that) */
- s_time_t budget_quota; /* Budget to which vCPU is entitled */
+ s_time_t budget_quota; /* Budget to which unit is entitled */
s_time_t start_time; /* Time we were scheduled (for credit) */
@@ -532,7 +532,7 @@ struct csched2_unit {
s_time_t avgload; /* Decaying queue load */
struct list_head runq_elem; /* On the runqueue (rqd->runq) */
- struct list_head parked_elem; /* On the parked_vcpus list */
+ struct list_head parked_elem; /* On the parked_units list */
struct list_head rqd_elem; /* On csched2_runqueue_data's svc list */
struct csched2_runqueue_data *migrate_rqd; /* Pre-determined migr. target */
int tickled_cpu; /* Cpu that will pick us (-1 if none) */
@@ -550,12 +550,12 @@ struct csched2_dom {
struct timer repl_timer; /* Timer for periodic replenishment of budget */
s_time_t next_repl; /* Time at which next replenishment occurs */
- struct list_head parked_vcpus; /* List of CPUs waiting for budget */
+ struct list_head parked_units; /* List of CPUs waiting for budget */
struct list_head sdom_elem; /* On csched2_runqueue_data's sdom list */
uint16_t weight; /* User specified weight */
uint16_t cap; /* User specified cap */
- uint16_t nr_vcpus; /* Number of vcpus of this domain */
+ uint16_t nr_units; /* Number of units of this domain */
};
/*
@@ -594,7 +594,7 @@ static inline struct csched2_runqueue_data *c2rqd(const struct scheduler *ops,
return &csched2_priv(ops)->rqd[c2r(cpu)];
}
-/* Does the domain of this vCPU have a cap? */
+/* Does the domain of this unit have a cap? */
static inline bool has_cap(const struct csched2_unit *svc)
{
return svc->budget != STIME_MAX;
@@ -612,24 +612,24 @@ static inline bool has_cap(const struct csched2_unit *svc)
* smt_idle mask.
*
* Once we have such a mask, it is easy to implement a policy that, either:
- * - uses fully idle cores first: it is enough to try to schedule the vcpus
+ * - uses fully idle cores first: it is enough to try to schedule the units
* on pcpus from smt_idle mask first. This is what happens if
* sched_smt_power_savings was not set at boot (default), and it maximizes
* true parallelism, and hence performance;
- * - uses already busy cores first: it is enough to try to schedule the vcpus
+ * - uses already busy cores first: it is enough to try to schedule the units
* on pcpus that are idle, but are not in smt_idle. This is what happens if
* sched_smt_power_savings is set at boot, and it allows as more cores as
* possible to stay in low power states, minimizing power consumption.
*
* This logic is entirely implemented in runq_tickle(), and that is enough.
- * In fact, in this scheduler, placement of a vcpu on one of the pcpus of a
+ * In fact, in this scheduler, placement of an unit on one of the pcpus of a
* runq, _always_ happens by means of tickling:
- * - when a vcpu wakes up, it calls csched2_unit_wake(), which calls
+ * - when an unit wakes up, it calls csched2_unit_wake(), which calls
* runq_tickle();
* - when a migration is initiated in schedule.c, we call csched2_res_pick(),
* csched2_unit_migrate() (which calls migrate()) and csched2_unit_wake().
* csched2_res_pick() looks for the least loaded runq and return just any
- * of its processors. Then, csched2_unit_migrate() just moves the vcpu to
+ * of its processors. Then, csched2_unit_migrate() just moves the unit to
* the chosen runq, and it is again runq_tickle(), called by
* csched2_unit_wake() that actually decides what pcpu to use within the
* chosen runq;
@@ -644,7 +644,7 @@ static inline bool has_cap(const struct csched2_unit *svc)
*
* NB that rqd->smt_idle is different than rqd->idle. rqd->idle
* records pcpus that at are merely idle (i.e., at the moment do not
- * have a vcpu running on them). But you have to manually filter out
+ * have an unit running on them). But you have to manually filter out
* which pcpus have been tickled in order to find cores that are not
* going to be busy soon. Filtering out tickled cpus pairwise is a
* lot of extra pain; so for rqd->smt_idle, we explicitly make so that
@@ -691,24 +691,24 @@ void smt_idle_mask_clear(unsigned int cpu, cpumask_t *mask)
*/
static int get_fallback_cpu(struct csched2_unit *svc)
{
- struct vcpu *v = svc->vcpu;
+ struct sched_unit *unit = svc->unit;
unsigned int bs;
SCHED_STAT_CRANK(need_fallback_cpu);
for_each_affinity_balance_step( bs )
{
- int cpu = v->processor;
+ int cpu = sched_unit_cpu(unit);
- if ( bs == BALANCE_SOFT_AFFINITY && !has_soft_affinity(v->sched_unit) )
+ if ( bs == BALANCE_SOFT_AFFINITY && !has_soft_affinity(unit) )
continue;
- affinity_balance_cpumask(v->sched_unit, bs, cpumask_scratch_cpu(cpu));
+ affinity_balance_cpumask(unit, bs, cpumask_scratch_cpu(cpu));
cpumask_and(cpumask_scratch_cpu(cpu), cpumask_scratch_cpu(cpu),
- cpupool_domain_cpumask(v->domain));
+ cpupool_domain_cpumask(unit->domain));
/*
- * This is cases 1 or 3 (depending on bs): if v->processor is (still)
+ * This is cases 1 or 3 (depending on bs): if processor is (still)
* in our affinity, go for it, for cache betterness.
*/
if ( likely(cpumask_test_cpu(cpu, cpumask_scratch_cpu(cpu))) )
@@ -730,7 +730,7 @@ static int get_fallback_cpu(struct csched2_unit *svc)
* We may well pick any valid pcpu from our soft-affinity, outside
* of our current runqueue, but we decide not to. In fact, changing
* runqueue is slow, affects load distribution, and is a source of
- * overhead for the vcpus running on the other runqueue (we need the
+ * overhead for the units running on the other runqueue (we need the
* lock). So, better do that as a consequence of a well informed
* decision (or if we really don't have any other chance, as we will,
* at step 5, if we get to there).
@@ -762,7 +762,7 @@ static int get_fallback_cpu(struct csched2_unit *svc)
* We can't be here. But if that somehow happen (in non-debug builds),
* at least return something which both online and in our hard-affinity.
*/
- return cpumask_any(cpumask_scratch_cpu(v->processor));
+ return cpumask_any(cpumask_scratch_cpu(sched_unit_cpu(unit)));
}
/*
@@ -791,7 +791,7 @@ static s_time_t c2t(struct csched2_runqueue_data *rqd, s_time_t credit, struct c
* Runqueue related code.
*/
-static inline int vcpu_on_runq(struct csched2_unit *svc)
+static inline int unit_on_runq(struct csched2_unit *svc)
{
return !list_empty(&svc->runq_elem);
}
@@ -949,17 +949,17 @@ _runq_assign(struct csched2_unit *svc, struct csched2_runqueue_data *rqd)
update_max_weight(svc->rqd, svc->weight, 0);
- /* Expected new load based on adding this vcpu */
+ /* Expected new load based on adding this unit */
rqd->b_avgload += svc->avgload;
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
unsigned rqi:16;
} d;
- d.dom = svc->vcpu->domain->domain_id;
- d.vcpu = svc->vcpu->vcpu_id;
+ d.dom = svc->unit->domain->domain_id;
+ d.unit = svc->unit->unit_id;
d.rqi=rqd->id;
__trace_var(TRC_CSCHED2_RUNQ_ASSIGN, 1,
sizeof(d),
@@ -969,13 +969,13 @@ _runq_assign(struct csched2_unit *svc, struct csched2_runqueue_data *rqd)
}
static void
-runq_assign(const struct scheduler *ops, struct vcpu *vc)
+runq_assign(const struct scheduler *ops, struct sched_unit *unit)
{
- struct csched2_unit *svc = vc->sched_unit->priv;
+ struct csched2_unit *svc = unit->priv;
ASSERT(svc->rqd == NULL);
- _runq_assign(svc, c2rqd(ops, vc->processor));
+ _runq_assign(svc, c2rqd(ops, sched_unit_cpu(unit)));
}
static void
@@ -983,24 +983,24 @@ _runq_deassign(struct csched2_unit *svc)
{
struct csched2_runqueue_data *rqd = svc->rqd;
- ASSERT(!vcpu_on_runq(svc));
+ ASSERT(!unit_on_runq(svc));
ASSERT(!(svc->flags & CSFLAG_scheduled));
list_del_init(&svc->rqd_elem);
update_max_weight(rqd, 0, svc->weight);
- /* Expected new load based on removing this vcpu */
+ /* Expected new load based on removing this unit */
rqd->b_avgload = max_t(s_time_t, rqd->b_avgload - svc->avgload, 0);
svc->rqd = NULL;
}
static void
-runq_deassign(const struct scheduler *ops, struct vcpu *vc)
+runq_deassign(const struct scheduler *ops, struct sched_unit *unit)
{
- struct csched2_unit *svc = vc->sched_unit->priv;
+ struct csched2_unit *svc = unit->priv;
- ASSERT(svc->rqd == c2rqd(ops, vc->processor));
+ ASSERT(svc->rqd == c2rqd(ops, sched_unit_cpu(unit)));
_runq_deassign(svc);
}
@@ -1203,15 +1203,15 @@ update_svc_load(const struct scheduler *ops,
struct csched2_unit *svc, int change, s_time_t now)
{
struct csched2_private *prv = csched2_priv(ops);
- s_time_t delta, vcpu_load;
+ s_time_t delta, unit_load;
unsigned int P, W;
if ( change == -1 )
- vcpu_load = 1;
+ unit_load = 1;
else if ( change == 1 )
- vcpu_load = 0;
+ unit_load = 0;
else
- vcpu_load = vcpu_runnable(svc->vcpu);
+ unit_load = unit_runnable(svc->unit);
W = prv->load_window_shift;
P = prv->load_precision_shift;
@@ -1219,7 +1219,7 @@ update_svc_load(const struct scheduler *ops,
if ( svc->load_last_update + (1ULL << W) < now )
{
- svc->avgload = vcpu_load << P;
+ svc->avgload = unit_load << P;
}
else
{
@@ -1232,7 +1232,7 @@ update_svc_load(const struct scheduler *ops,
}
svc->avgload = svc->avgload +
- ((delta * (vcpu_load << P)) >> W) -
+ ((delta * (unit_load << P)) >> W) -
((delta * svc->avgload) >> W);
}
svc->load_last_update = now;
@@ -1244,14 +1244,14 @@ update_svc_load(const struct scheduler *ops,
{
struct {
uint64_t v_avgload;
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
unsigned shift;
} d;
- d.dom = svc->vcpu->domain->domain_id;
- d.vcpu = svc->vcpu->vcpu_id;
+ d.dom = svc->unit->domain->domain_id;
+ d.unit = svc->unit->unit_id;
d.v_avgload = svc->avgload;
d.shift = P;
- __trace_var(TRC_CSCHED2_UPDATE_VCPU_LOAD, 1,
+ __trace_var(TRC_CSCHED2_UPDATE_UNIT_LOAD, 1,
sizeof(d),
(unsigned char *)&d);
}
@@ -1273,18 +1273,18 @@ static void
runq_insert(const struct scheduler *ops, struct csched2_unit *svc)
{
struct list_head *iter;
- unsigned int cpu = svc->vcpu->processor;
+ unsigned int cpu = sched_unit_cpu(svc->unit);
struct list_head * runq = &c2rqd(ops, cpu)->runq;
int pos = 0;
ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
- ASSERT(!vcpu_on_runq(svc));
- ASSERT(c2r(cpu) == c2r(svc->vcpu->processor));
+ ASSERT(!unit_on_runq(svc));
+ ASSERT(c2r(cpu) == c2r(sched_unit_cpu(svc->unit)));
ASSERT(&svc->rqd->runq == runq);
- ASSERT(!is_idle_vcpu(svc->vcpu));
- ASSERT(!svc->vcpu->sched_unit->is_running);
+ ASSERT(!is_idle_unit(svc->unit));
+ ASSERT(!svc->unit->is_running);
ASSERT(!(svc->flags & CSFLAG_scheduled));
list_for_each( iter, runq )
@@ -1301,11 +1301,11 @@ runq_insert(const struct scheduler *ops, struct csched2_unit *svc)
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
unsigned pos;
} d;
- d.dom = svc->vcpu->domain->domain_id;
- d.vcpu = svc->vcpu->vcpu_id;
+ d.dom = svc->unit->domain->domain_id;
+ d.unit = svc->unit->unit_id;
d.pos = pos;
__trace_var(TRC_CSCHED2_RUNQ_POS, 1,
sizeof(d),
@@ -1315,7 +1315,7 @@ runq_insert(const struct scheduler *ops, struct csched2_unit *svc)
static inline void runq_remove(struct csched2_unit *svc)
{
- ASSERT(vcpu_on_runq(svc));
+ ASSERT(unit_on_runq(svc));
list_del_init(&svc->runq_elem);
}
@@ -1341,8 +1341,8 @@ static inline bool is_preemptable(const struct csched2_unit *svc,
if ( ratelimit <= CSCHED2_RATELIMIT_TICKLE_TOLERANCE )
return true;
- ASSERT(svc->vcpu->sched_unit->is_running);
- return now - svc->vcpu->sched_unit->state_entry_time >
+ ASSERT(svc->unit->is_running);
+ return now - svc->unit->state_entry_time >
ratelimit - CSCHED2_RATELIMIT_TICKLE_TOLERANCE;
}
@@ -1370,17 +1370,17 @@ static s_time_t tickle_score(const struct scheduler *ops, s_time_t now,
/*
* We are dealing with cpus that are marked non-idle (i.e., that are not
- * in rqd->idle). However, some of them may be running their idle vcpu,
+ * in rqd->idle). However, some of them may be running their idle unit,
* if taking care of tasklets. In that case, we want to leave it alone.
*/
- if ( unlikely(is_idle_vcpu(cur->vcpu) ||
+ if ( unlikely(is_idle_unit(cur->unit) ||
!is_preemptable(cur, now, MICROSECS(prv->ratelimit_us))) )
return -1;
burn_credits(rqd, cur, now);
score = new->credit - cur->credit;
- if ( new->vcpu->processor != cpu )
+ if ( sched_unit_cpu(new->unit) != cpu )
score -= CSCHED2_MIGRATE_RESIST;
/*
@@ -1391,21 +1391,21 @@ static s_time_t tickle_score(const struct scheduler *ops, s_time_t now,
*/
if ( score > 0 )
{
- if ( cpumask_test_cpu(cpu, new->vcpu->sched_unit->cpu_soft_affinity) )
+ if ( cpumask_test_cpu(cpu, new->unit->cpu_soft_affinity) )
score += CSCHED2_CREDIT_INIT;
- if ( !cpumask_test_cpu(cpu, cur->vcpu->sched_unit->cpu_soft_affinity) )
+ if ( !cpumask_test_cpu(cpu, cur->unit->cpu_soft_affinity) )
score += CSCHED2_CREDIT_INIT;
}
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
int credit, score;
} d;
- d.dom = cur->vcpu->domain->domain_id;
- d.vcpu = cur->vcpu->vcpu_id;
+ d.dom = cur->unit->domain->domain_id;
+ d.unit = cur->unit->unit_id;
d.credit = cur->credit;
d.score = score;
__trace_var(TRC_CSCHED2_TICKLE_CHECK, 1,
@@ -1417,14 +1417,14 @@ static s_time_t tickle_score(const struct scheduler *ops, s_time_t now,
}
/*
- * Check what processor it is best to 'wake', for picking up a vcpu that has
+ * Check what processor it is best to 'wake', for picking up an unit that has
* just been put (back) in the runqueue. Logic is as follows:
* 1. if there are idle processors in the runq, wake one of them;
- * 2. if there aren't idle processor, check the one were the vcpu was
+ * 2. if there aren't idle processor, check the one were the unit was
* running before to see if we can preempt what's running there now
* (and hence doing just one migration);
- * 3. last stand: check all processors and see if the vcpu is in right
- * of preempting any of the other vcpus running on them (this requires
+ * 3. last stand: check all processors and see if the unit is in right
+ * of preempting any of the other units running on them (this requires
* two migrations, and that's indeed why it is left as the last stand).
*
* Note that when we say 'idle processors' what we really mean is (pretty
@@ -1437,10 +1437,10 @@ runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
{
int i, ipid = -1;
s_time_t max = 0;
- struct sched_unit *unit = new->vcpu->sched_unit;
- unsigned int bs, cpu = new->vcpu->processor;
+ struct sched_unit *unit = new->unit;
+ unsigned int bs, cpu = sched_unit_cpu(unit);
struct csched2_runqueue_data *rqd = c2rqd(ops, cpu);
- cpumask_t *online = cpupool_domain_cpumask(new->vcpu->domain);
+ cpumask_t *online = cpupool_domain_cpumask(unit->domain);
cpumask_t mask;
ASSERT(new->rqd == rqd);
@@ -1448,13 +1448,13 @@ runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
unsigned processor;
int credit;
} d;
- d.dom = new->vcpu->domain->domain_id;
- d.vcpu = new->vcpu->vcpu_id;
- d.processor = new->vcpu->processor;
+ d.dom = unit->domain->domain_id;
+ d.unit = unit->unit_id;
+ d.processor = cpu;
d.credit = new->credit;
__trace_var(TRC_CSCHED2_TICKLE_NEW, 1,
sizeof(d),
@@ -1462,11 +1462,11 @@ runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
}
/*
- * Exclusive pinning is when a vcpu has hard-affinity with only one
- * cpu, and there is no other vcpu that has hard-affinity with that
+ * Exclusive pinning is when an unit has hard-affinity with only one
+ * cpu, and there is no other unit that has hard-affinity with that
* same cpu. This is infrequent, but if it happens, is for achieving
* the most possible determinism, and least possible overhead for
- * the vcpus in question.
+ * the units in question.
*
* Try to identify the vast majority of these situations, and deal
* with them quickly.
@@ -1533,7 +1533,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
/*
* Note that, if we are here, it means we have done the hard-affinity
* balancing step of the loop, and hence what we have in cpumask_scratch
- * is what we put there for last, i.e., new's vcpu_hard_affinity & online
+ * is what we put there for last, i.e., new's unit_hard_affinity & online
* which is exactly what we need for the next part of the function.
*/
@@ -1544,7 +1544,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
*
* For deciding which cpu to tickle, we use tickle_score(), which will
* factor in both new's soft-affinity, and the soft-affinity of the
- * vcpu running on each cpu that we consider.
+ * unit running on each cpu that we consider.
*/
cpumask_andnot(&mask, &rqd->active, &rqd->idle);
cpumask_andnot(&mask, &mask, &rqd->tickled);
@@ -1589,7 +1589,7 @@ runq_tickle(const struct scheduler *ops, struct csched2_unit *new, s_time_t now)
return;
}
- ASSERT(!is_idle_vcpu(curr_on_cpu(ipid)->vcpu_list));
+ ASSERT(!is_idle_unit(curr_on_cpu(ipid)));
SCHED_STAT_CRANK(tickled_busy_cpu);
tickle:
BUG_ON(ipid == -1);
@@ -1624,16 +1624,16 @@ static void reset_credit(const struct scheduler *ops, int cpu, s_time_t now,
/*
* Under normal circumstances, snext->credit should never be less
- * than -CSCHED2_MIN_TIMER. However, under some circumstances, a
- * vcpu with low credits may be allowed to run long enough that
+ * than -CSCHED2_MIN_TIMER. However, under some circumstances, an
+ * unit with low credits may be allowed to run long enough that
* its credits are actually less than -CSCHED2_CREDIT_INIT.
- * (Instances have been observed, for example, where a vcpu with
+ * (Instances have been observed, for example, where an unit 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.)
*
* If this is the case for snext, we simply want to keep moving
* everyone up until it is in the black again. This fair because
- * none of the other vcpus want to run at the moment.
+ * none of the other units want to run at the moment.
*
* Rather than looping, however, we just calculate a multiplier,
* avoiding an integer division and multiplication in the common
@@ -1650,16 +1650,16 @@ static void reset_credit(const struct scheduler *ops, int cpu, s_time_t now,
int start_credit;
svc = list_entry(iter, struct csched2_unit, rqd_elem);
- svc_cpu = svc->vcpu->processor;
+ svc_cpu = sched_unit_cpu(svc->unit);
- ASSERT(!is_idle_vcpu(svc->vcpu));
+ ASSERT(!is_idle_unit(svc->unit));
ASSERT(svc->rqd == rqd);
/*
* If svc is running, it is our responsibility to make sure, here,
* that the credit it has spent so far get accounted.
*/
- if ( svc->vcpu == curr_on_cpu(svc_cpu)->vcpu_list )
+ if ( svc->unit == curr_on_cpu(svc_cpu) )
{
burn_credits(rqd, svc, now);
/*
@@ -1690,12 +1690,12 @@ static void reset_credit(const struct scheduler *ops, int cpu, s_time_t now,
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
int credit_start, credit_end;
unsigned multiplier;
} d;
- d.dom = svc->vcpu->domain->domain_id;
- d.vcpu = svc->vcpu->vcpu_id;
+ d.dom = svc->unit->domain->domain_id;
+ d.unit = svc->unit->unit_id;
d.credit_start = start_credit;
d.credit_end = svc->credit;
d.multiplier = m;
@@ -1715,9 +1715,9 @@ void burn_credits(struct csched2_runqueue_data *rqd,
{
s_time_t delta;
- ASSERT(svc == csched2_unit(curr_on_cpu(svc->vcpu->processor)));
+ ASSERT(svc == csched2_unit(curr_on_cpu(sched_unit_cpu(svc->unit))));
- if ( unlikely(is_idle_vcpu(svc->vcpu)) )
+ if ( unlikely(is_idle_unit(svc->unit)) )
{
ASSERT(svc->credit == CSCHED2_IDLE_CREDIT);
return;
@@ -1746,12 +1746,12 @@ void burn_credits(struct csched2_runqueue_data *rqd,
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
int credit, budget;
int delta;
} d;
- d.dom = svc->vcpu->domain->domain_id;
- d.vcpu = svc->vcpu->vcpu_id;
+ d.dom = svc->unit->domain->domain_id;
+ d.unit = svc->unit->unit_id;
d.credit = svc->credit;
d.budget = has_cap(svc) ? svc->budget : INT_MIN;
d.delta = delta;
@@ -1765,39 +1765,39 @@ void burn_credits(struct csched2_runqueue_data *rqd,
* Budget-related code.
*/
-static void park_vcpu(struct csched2_unit *svc)
+static void park_unit(struct csched2_unit *svc)
{
- struct vcpu *v = svc->vcpu;
+ struct sched_unit *unit = svc->unit;
ASSERT(spin_is_locked(&svc->sdom->budget_lock));
/*
- * It was impossible to find budget for this vCPU, so it has to be
+ * It was impossible to find budget for this unit, so it has to be
* "parked". This implies it is not runnable, so we mark it as such in
- * its pause_flags. If the vCPU is currently scheduled (which means we
+ * its pause_flags. If the unit is currently scheduled (which means we
* are here after being called from within csched_schedule()), flagging
* is enough, as we'll choose someone else, and then context_saved()
* will take care of updating the load properly.
*
- * If, OTOH, the vCPU is sitting in the runqueue (which means we are here
+ * If, OTOH, the unit is sitting in the runqueue (which means we are here
* after being called from within runq_candidate()), we must go all the
* way down to taking it out of there, and updating the load accordingly.
*
- * In both cases, we also add it to the list of parked vCPUs of the domain.
+ * In both cases, we also add it to the list of parked units of the domain.
*/
- __set_bit(_VPF_parked, &v->pause_flags);
- if ( vcpu_on_runq(svc) )
+ sched_set_pause_flags(unit, _VPF_parked);
+ if ( unit_on_runq(svc) )
{
runq_remove(svc);
update_load(svc->sdom->dom->cpupool->sched, svc->rqd, svc, -1, NOW());
}
- list_add(&svc->parked_elem, &svc->sdom->parked_vcpus);
+ list_add(&svc->parked_elem, &svc->sdom->parked_units);
}
-static bool vcpu_grab_budget(struct csched2_unit *svc)
+static bool unit_grab_budget(struct csched2_unit *svc)
{
struct csched2_dom *sdom = svc->sdom;
- unsigned int cpu = svc->vcpu->processor;
+ unsigned int cpu = sched_unit_cpu(svc->unit);
ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
@@ -1809,9 +1809,9 @@ static bool vcpu_grab_budget(struct csched2_unit *svc)
/*
* Here, svc->budget is <= 0 (as, if it was > 0, we'd have taken the if
- * above!). That basically means the vCPU has overrun a bit --because of
+ * above!). That basically means the unit has overrun a bit --because of
* various reasons-- and we want to take that into account. With the +=,
- * we are actually subtracting the amount of budget the vCPU has
+ * we are actually subtracting the amount of budget the unit has
* overconsumed, from the total domain budget.
*/
sdom->budget += svc->budget;
@@ -1832,7 +1832,7 @@ static bool vcpu_grab_budget(struct csched2_unit *svc)
else
{
svc->budget = 0;
- park_vcpu(svc);
+ park_unit(svc);
}
spin_unlock(&sdom->budget_lock);
@@ -1841,10 +1841,10 @@ static bool vcpu_grab_budget(struct csched2_unit *svc)
}
static void
-vcpu_return_budget(struct csched2_unit *svc, struct list_head *parked)
+unit_return_budget(struct csched2_unit *svc, struct list_head *parked)
{
struct csched2_dom *sdom = svc->sdom;
- unsigned int cpu = svc->vcpu->processor;
+ unsigned int cpu = sched_unit_cpu(svc->unit);
ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
ASSERT(list_empty(parked));
@@ -1853,7 +1853,7 @@ vcpu_return_budget(struct csched2_unit *svc, struct list_head *parked)
spin_lock(&sdom->budget_lock);
/*
- * The vCPU is stopping running (e.g., because it's blocking, or it has
+ * The unit is stopping running (e.g., because it's blocking, or it has
* been preempted). If it hasn't consumed all the budget it got when,
* starting to run, put that remaining amount back in the domain's budget
* pool.
@@ -1862,58 +1862,58 @@ vcpu_return_budget(struct csched2_unit *svc, struct list_head *parked)
svc->budget = 0;
/*
- * Making budget available again to the domain means that parked vCPUs
- * may be unparked and run. They are, if any, in the domain's parked_vcpus
+ * Making budget available again to the domain means that parked units
+ * may be unparked and run. They are, if any, in the domain's parked_units
* list, so we want to go through that and unpark them (so they can try
* to get some budget).
*
* Touching the list requires the budget_lock, which we hold. Let's
* therefore put everyone in that list in another, temporary list, which
- * then the caller will traverse, unparking the vCPUs it finds there.
+ * then the caller will traverse, unparking the units it finds there.
*
* In fact, we can't do the actual unparking here, because that requires
- * taking the runqueue lock of the vCPUs being unparked, and we can't
+ * taking the runqueue lock of the units being unparked, and we can't
* take any runqueue locks while we hold a budget_lock.
*/
if ( sdom->budget > 0 )
- list_splice_init(&sdom->parked_vcpus, parked);
+ list_splice_init(&sdom->parked_units, parked);
spin_unlock(&sdom->budget_lock);
}
static void
-unpark_parked_vcpus(const struct scheduler *ops, struct list_head *vcpus)
+unpark_parked_units(const struct scheduler *ops, struct list_head *units)
{
struct csched2_unit *svc, *tmp;
spinlock_t *lock;
- list_for_each_entry_safe(svc, tmp, vcpus, parked_elem)
+ list_for_each_entry_safe ( svc, tmp, units, parked_elem )
{
unsigned long flags;
s_time_t now;
- lock = unit_schedule_lock_irqsave(svc->vcpu->sched_unit, &flags);
+ lock = unit_schedule_lock_irqsave(svc->unit, &flags);
- __clear_bit(_VPF_parked, &svc->vcpu->pause_flags);
+ sched_clear_pause_flags(svc->unit, _VPF_parked);
if ( unlikely(svc->flags & CSFLAG_scheduled) )
{
/*
* We end here if a budget replenishment arrived between
* csched2_schedule() (and, in particular, after a call to
- * vcpu_grab_budget() that returned false), and
+ * unit_grab_budget() that returned false), and
* context_saved(). By setting __CSFLAG_delayed_runq_add,
- * we tell context_saved() to put the vCPU back in the
+ * we tell context_saved() to put the unit back in the
* runqueue, from where it will compete with the others
* for the newly replenished budget.
*/
ASSERT( svc->rqd != NULL );
- ASSERT( c2rqd(ops, svc->vcpu->processor) == svc->rqd );
+ ASSERT( c2rqd(ops, sched_unit_cpu(svc->unit)) == svc->rqd );
__set_bit(__CSFLAG_delayed_runq_add, &svc->flags);
}
- else if ( vcpu_runnable(svc->vcpu) )
+ else if ( unit_runnable(svc->unit) )
{
/*
- * The vCPU should go back to the runqueue, and compete for
+ * The unit should go back to the runqueue, and compete for
* the newly replenished budget, but only if it is actually
* runnable (and was therefore offline only because of the
* lack of budget).
@@ -1925,7 +1925,7 @@ unpark_parked_vcpus(const struct scheduler *ops, struct list_head *vcpus)
}
list_del_init(&svc->parked_elem);
- unit_schedule_unlock_irqrestore(lock, flags, svc->vcpu->sched_unit);
+ unit_schedule_unlock_irqrestore(lock, flags, svc->unit);
}
}
@@ -1955,7 +1955,7 @@ static void replenish_domain_budget(void* data)
*
* Even in cases of overrun or delay, however, we expect that in 99% of
* cases, doing just one replenishment will be good enough for being able
- * to unpark the vCPUs that are waiting for some budget.
+ * to unpark the units that are waiting for some budget.
*/
do_replenish(sdom);
@@ -1975,7 +1975,7 @@ static void replenish_domain_budget(void* data)
}
/*
* 2) if we overrun by more than tot_budget, then budget+tot_budget is
- * still < 0, which means that we can't unpark the vCPUs. Let's bail,
+ * still < 0, which means that we can't unpark the units. Let's bail,
* and wait for future replenishments.
*/
if ( unlikely(sdom->budget <= 0) )
@@ -1989,14 +1989,14 @@ static void replenish_domain_budget(void* data)
/*
* As above, let's prepare the temporary list, out of the domain's
- * parked_vcpus list, now that we hold the budget_lock. Then, drop such
+ * parked_units list, now that we hold the budget_lock. Then, drop such
* lock, and pass the list to the unparking function.
*/
- list_splice_init(&sdom->parked_vcpus, &parked);
+ list_splice_init(&sdom->parked_units, &parked);
spin_unlock_irqrestore(&sdom->budget_lock, flags);
- unpark_parked_vcpus(sdom->dom->cpupool->sched, &parked);
+ unpark_parked_units(sdom->dom->cpupool->sched, &parked);
out:
set_timer(&sdom->repl_timer, sdom->next_repl);
@@ -2004,37 +2004,36 @@ static void replenish_domain_budget(void* data)
#ifndef NDEBUG
static inline void
-csched2_vcpu_check(struct vcpu *vc)
+csched2_unit_check(struct sched_unit *unit)
{
- struct csched2_unit * const svc = csched2_unit(vc->sched_unit);
+ struct csched2_unit * const svc = csched2_unit(unit);
struct csched2_dom * const sdom = svc->sdom;
- BUG_ON( svc->vcpu != vc );
- BUG_ON( sdom != csched2_dom(vc->domain) );
+ BUG_ON( svc->unit != unit );
+ BUG_ON( sdom != csched2_dom(unit->domain) );
if ( sdom )
{
- BUG_ON( is_idle_vcpu(vc) );
- BUG_ON( sdom->dom != vc->domain );
+ BUG_ON( is_idle_unit(unit) );
+ BUG_ON( sdom->dom != unit->domain );
}
else
{
- BUG_ON( !is_idle_vcpu(vc) );
+ BUG_ON( !is_idle_unit(unit) );
}
SCHED_STAT_CRANK(unit_check);
}
-#define CSCHED2_VCPU_CHECK(_vc) (csched2_vcpu_check(_vc))
+#define CSCHED2_UNIT_CHECK(unit) (csched2_unit_check(unit))
#else
-#define CSCHED2_VCPU_CHECK(_vc)
+#define CSCHED2_UNIT_CHECK(unit)
#endif
static void *
csched2_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
void *dd)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched2_unit *svc;
- /* Allocate per-VCPU info */
+ /* Allocate per-UNIT info */
svc = xzalloc(struct csched2_unit);
if ( svc == NULL )
return NULL;
@@ -2043,10 +2042,10 @@ csched2_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
INIT_LIST_HEAD(&svc->runq_elem);
svc->sdom = dd;
- svc->vcpu = vc;
+ svc->unit = unit;
svc->flags = 0U;
- if ( ! is_idle_vcpu(vc) )
+ if ( ! is_idle_unit(unit) )
{
ASSERT(svc->sdom != NULL);
svc->credit = CSCHED2_CREDIT_INIT;
@@ -2075,19 +2074,18 @@ csched2_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
static void
csched2_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched2_unit * const svc = csched2_unit(unit);
- ASSERT(!is_idle_vcpu(vc));
+ ASSERT(!is_idle_unit(unit));
SCHED_STAT_CRANK(unit_sleep);
- if ( curr_on_cpu(vc->processor) == unit )
+ if ( curr_on_cpu(sched_unit_cpu(unit)) == unit )
{
- tickle_cpu(vc->processor, svc->rqd);
+ tickle_cpu(sched_unit_cpu(unit), svc->rqd);
}
- else if ( vcpu_on_runq(svc) )
+ else if ( unit_on_runq(svc) )
{
- ASSERT(svc->rqd == c2rqd(ops, vc->processor));
+ ASSERT(svc->rqd == c2rqd(ops, sched_unit_cpu(unit)));
update_load(ops, svc->rqd, svc, -1, NOW());
runq_remove(svc);
}
@@ -2098,14 +2096,13 @@ csched2_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
static void
csched2_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched2_unit * const svc = csched2_unit(unit);
- unsigned int cpu = vc->processor;
+ unsigned int cpu = sched_unit_cpu(unit);
s_time_t now;
ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
- ASSERT(!is_idle_vcpu(vc));
+ ASSERT(!is_idle_unit(unit));
if ( unlikely(curr_on_cpu(cpu) == unit) )
{
@@ -2113,18 +2110,18 @@ csched2_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
goto out;
}
- if ( unlikely(vcpu_on_runq(svc)) )
+ if ( unlikely(unit_on_runq(svc)) )
{
SCHED_STAT_CRANK(unit_wake_onrunq);
goto out;
}
- if ( likely(vcpu_runnable(vc)) )
+ if ( likely(unit_runnable(unit)) )
SCHED_STAT_CRANK(unit_wake_runnable);
else
SCHED_STAT_CRANK(unit_wake_not_runnable);
- /* If the context hasn't been saved for this vcpu yet, we can't put it on
+ /* If the context hasn't been saved for this unit yet, we can't put it on
* another runqueue. Instead, we set a flag so that it will be put on the runqueue
* after the context has been saved. */
if ( unlikely(svc->flags & CSFLAG_scheduled) )
@@ -2135,15 +2132,15 @@ csched2_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
/* Add into the new runqueue if necessary */
if ( svc->rqd == NULL )
- runq_assign(ops, vc);
+ runq_assign(ops, unit);
else
- ASSERT(c2rqd(ops, vc->processor) == svc->rqd );
+ ASSERT(c2rqd(ops, sched_unit_cpu(unit)) == svc->rqd );
now = NOW();
update_load(ops, svc->rqd, svc, 1, now);
-
- /* Put the VCPU on the runq */
+
+ /* Put the UNIT on the runq */
runq_insert(ops, svc);
runq_tickle(ops, svc, now);
@@ -2156,49 +2153,48 @@ csched2_unit_yield(const struct scheduler *ops, struct sched_unit *unit)
{
struct csched2_unit * const svc = csched2_unit(unit);
- __set_bit(__CSFLAG_vcpu_yield, &svc->flags);
+ __set_bit(__CSFLAG_unit_yield, &svc->flags);
}
static void
csched2_context_saved(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched2_unit * const svc = csched2_unit(unit);
spinlock_t *lock = unit_schedule_lock_irq(unit);
s_time_t now = NOW();
LIST_HEAD(were_parked);
- BUG_ON( !is_idle_vcpu(vc) && svc->rqd != c2rqd(ops, vc->processor));
- ASSERT(is_idle_vcpu(vc) || svc->rqd == c2rqd(ops, vc->processor));
+ BUG_ON( !is_idle_unit(unit) && svc->rqd != c2rqd(ops, sched_unit_cpu(unit)));
+ ASSERT(is_idle_unit(unit) || svc->rqd == c2rqd(ops, sched_unit_cpu(unit)));
- /* This vcpu is now eligible to be put on the runqueue again */
+ /* This unit is now eligible to be put on the runqueue again */
__clear_bit(__CSFLAG_scheduled, &svc->flags);
if ( unlikely(has_cap(svc) && svc->budget > 0) )
- vcpu_return_budget(svc, &were_parked);
+ unit_return_budget(svc, &were_parked);
/* If someone wants it on the runqueue, put it there. */
/*
* NB: We can get rid of CSFLAG_scheduled by checking for
- * vc->is_running and vcpu_on_runq(svc) here. However,
+ * vc->is_running and unit_on_runq(svc) here. However,
* since we're accessing the flags cacheline anyway,
* it seems a bit pointless; especially as we have plenty of
* bits free.
*/
if ( __test_and_clear_bit(__CSFLAG_delayed_runq_add, &svc->flags)
- && likely(vcpu_runnable(vc)) )
+ && likely(unit_runnable(unit)) )
{
- ASSERT(!vcpu_on_runq(svc));
+ ASSERT(!unit_on_runq(svc));
runq_insert(ops, svc);
runq_tickle(ops, svc, now);
}
- else if ( !is_idle_vcpu(vc) )
+ else if ( !is_idle_unit(unit) )
update_load(ops, svc->rqd, svc, -1, now);
unit_schedule_unlock_irq(lock, unit);
- unpark_parked_vcpus(ops, &were_parked);
+ unpark_parked_units(ops, &were_parked);
}
#define MAX_LOAD (STIME_MAX)
@@ -2206,9 +2202,8 @@ static struct sched_resource *
csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
struct csched2_private *prv = csched2_priv(ops);
- struct vcpu *vc = unit->vcpu_list;
int i, min_rqi = -1, min_s_rqi = -1;
- unsigned int new_cpu, cpu = vc->processor;
+ unsigned int new_cpu, cpu = sched_unit_cpu(unit);
struct csched2_unit *svc = csched2_unit(unit);
s_time_t min_avgload = MAX_LOAD, min_s_avgload = MAX_LOAD;
bool has_soft;
@@ -2246,7 +2241,7 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
}
cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
- cpupool_domain_cpumask(vc->domain));
+ cpupool_domain_cpumask(unit->domain));
/*
* First check to see if we're here because someone else suggested a place
@@ -2357,7 +2352,7 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
* We have soft affinity, and we have a candidate runq, so go for it.
*
* Note that, to obtain the soft-affinity mask, we "just" put what we
- * have in cpumask_scratch in && with vc->cpu_soft_affinity. This is
+ * have in cpumask_scratch in && with unit->cpu_soft_affinity. This is
* ok because:
* - we know that unit->cpu_hard_affinity and ->cpu_soft_affinity have
* a non-empty intersection (because has_soft is true);
@@ -2380,7 +2375,7 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
* any suitable runq. But we did find one when considering hard
* affinity, so go for it.
*
- * cpumask_scratch already has vc->cpu_hard_affinity &
+ * cpumask_scratch already has unit->cpu_hard_affinity &
* cpupool_domain_cpumask() in it, so it's enough that we filter
* with the cpus of the runq.
*/
@@ -2411,11 +2406,11 @@ csched2_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
struct {
uint64_t b_avgload;
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
unsigned rq_id:16, new_cpu:16;
} d;
- d.dom = vc->domain->domain_id;
- d.vcpu = vc->vcpu_id;
+ d.dom = unit->domain->domain_id;
+ d.unit = unit->unit_id;
d.rq_id = min_rqi;
d.b_avgload = min_avgload;
d.new_cpu = new_cpu;
@@ -2434,10 +2429,10 @@ typedef struct {
struct csched2_unit * best_push_svc, *best_pull_svc;
/* NB: Read by consider() */
struct csched2_runqueue_data *lrqd;
- struct csched2_runqueue_data *orqd;
+ struct csched2_runqueue_data *orqd;
} balance_state_t;
-static void consider(balance_state_t *st,
+static void consider(balance_state_t *st,
struct csched2_unit *push_svc,
struct csched2_unit *pull_svc)
{
@@ -2476,17 +2471,17 @@ static void migrate(const struct scheduler *ops,
struct csched2_runqueue_data *trqd,
s_time_t now)
{
- int cpu = svc->vcpu->processor;
- struct sched_unit *unit = svc->vcpu->sched_unit;
+ struct sched_unit *unit = svc->unit;
+ int cpu = sched_unit_cpu(unit);
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
unsigned rqi:16, trqi:16;
} d;
- d.dom = svc->vcpu->domain->domain_id;
- d.vcpu = svc->vcpu->vcpu_id;
+ d.dom = unit->domain->domain_id;
+ d.unit = unit->unit_id;
d.rqi = svc->rqd->id;
d.trqi = trqd->id;
__trace_var(TRC_CSCHED2_MIGRATE, 1,
@@ -2498,7 +2493,7 @@ static void migrate(const struct scheduler *ops,
{
/* It's running; mark it to migrate. */
svc->migrate_rqd = trqd;
- __set_bit(_VPF_migrating, &svc->vcpu->pause_flags);
+ sched_set_pause_flags(unit, _VPF_migrating);
__set_bit(__CSFLAG_runq_migrate_request, &svc->flags);
SCHED_STAT_CRANK(migrate_requested);
tickle_cpu(cpu, svc->rqd);
@@ -2507,7 +2502,7 @@ static void migrate(const struct scheduler *ops,
{
int on_runq = 0;
/* It's not running; just move it */
- if ( vcpu_on_runq(svc) )
+ if ( unit_on_runq(svc) )
{
runq_remove(svc);
update_load(ops, svc->rqd, NULL, -1, now);
@@ -2516,14 +2511,14 @@ static void migrate(const struct scheduler *ops,
_runq_deassign(svc);
cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
- cpupool_domain_cpumask(svc->vcpu->domain));
+ cpupool_domain_cpumask(unit->domain));
cpumask_and(cpumask_scratch_cpu(cpu), cpumask_scratch_cpu(cpu),
&trqd->active);
- svc->vcpu->processor = cpumask_cycle(trqd->pick_bias,
- cpumask_scratch_cpu(cpu));
- svc->vcpu->sched_unit->res = get_sched_res(svc->vcpu->processor);
- trqd->pick_bias = svc->vcpu->processor;
- ASSERT(svc->vcpu->processor < nr_cpu_ids);
+ sched_set_res(unit,
+ get_sched_res(cpumask_cycle(trqd->pick_bias,
+ cpumask_scratch_cpu(cpu))));
+ trqd->pick_bias = sched_unit_cpu(unit);
+ ASSERT(sched_unit_cpu(unit) < nr_cpu_ids);
_runq_assign(svc, trqd);
if ( on_runq )
@@ -2543,14 +2538,14 @@ static void migrate(const struct scheduler *ops,
* - svc is not already flagged to migrate,
* - if svc is allowed to run on at least one of the pcpus of rqd.
*/
-static bool vcpu_is_migrateable(struct csched2_unit *svc,
+static bool unit_is_migrateable(struct csched2_unit *svc,
struct csched2_runqueue_data *rqd)
{
- struct vcpu *v = svc->vcpu;
- int cpu = svc->vcpu->processor;
+ struct sched_unit *unit = svc->unit;
+ int cpu = sched_unit_cpu(unit);
- cpumask_and(cpumask_scratch_cpu(cpu), v->sched_unit->cpu_hard_affinity,
- cpupool_domain_cpumask(v->domain));
+ cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
+ cpupool_domain_cpumask(unit->domain));
return !(svc->flags & CSFLAG_runq_migrate_request) &&
cpumask_intersects(cpumask_scratch_cpu(cpu), &rqd->active);
@@ -2587,7 +2582,7 @@ retry:
for_each_cpu(i, &prv->active_queues)
{
s_time_t delta;
-
+
st.orqd = prv->rqd + i;
if ( st.orqd == st.lrqd
@@ -2595,7 +2590,7 @@ retry:
continue;
update_runq_load(ops, st.orqd, 0, now);
-
+
delta = st.lrqd->b_avgload - st.orqd->b_avgload;
if ( delta < 0 )
delta = -delta;
@@ -2618,7 +2613,7 @@ retry:
s_time_t load_max;
int cpus_max;
-
+
load_max = st.lrqd->b_avgload;
if ( st.orqd->b_avgload > load_max )
load_max = st.orqd->b_avgload;
@@ -2657,7 +2652,7 @@ retry:
opt_overload_balance_tolerance)) )
goto out;
}
-
+
/* Try to grab the other runqueue lock; if it's been taken in the
* meantime, try the process over again. This can't deadlock
* because if it doesn't get any other rqd locks, it will simply
@@ -2697,17 +2692,17 @@ retry:
update_svc_load(ops, push_svc, 0, now);
- if ( !vcpu_is_migrateable(push_svc, st.orqd) )
+ if ( !unit_is_migrateable(push_svc, st.orqd) )
continue;
list_for_each( pull_iter, &st.orqd->svc )
{
struct csched2_unit * pull_svc = list_entry(pull_iter, struct csched2_unit, rqd_elem);
-
+
if ( !inner_load_updated )
update_svc_load(ops, pull_svc, 0, now);
-
- if ( !vcpu_is_migrateable(pull_svc, st.lrqd) )
+
+ if ( !unit_is_migrateable(pull_svc, st.lrqd) )
continue;
consider(&st, push_svc, pull_svc);
@@ -2722,8 +2717,8 @@ retry:
list_for_each( pull_iter, &st.orqd->svc )
{
struct csched2_unit * pull_svc = list_entry(pull_iter, struct csched2_unit, rqd_elem);
-
- if ( !vcpu_is_migrateable(pull_svc, st.lrqd) )
+
+ if ( !unit_is_migrateable(pull_svc, st.lrqd) )
continue;
/* Consider pull only */
@@ -2746,8 +2741,7 @@ static void
csched2_unit_migrate(
const struct scheduler *ops, struct sched_unit *unit, unsigned int new_cpu)
{
- struct vcpu *vc = unit->vcpu_list;
- struct domain *d = vc->domain;
+ struct domain *d = unit->domain;
struct csched2_unit * const svc = csched2_unit(unit);
struct csched2_runqueue_data *trqd;
s_time_t now = NOW();
@@ -2759,25 +2753,24 @@ csched2_unit_migrate(
* cpupool.
*
* And since there indeed is the chance that it is not part of it, all
- * we must do is remove _and_ unassign the vCPU from any runqueue, as
+ * we must do is remove _and_ unassign the unit from any runqueue, as
* well as updating v->processor with the target, so that the suspend
* process can continue.
*
* It will then be during resume that a new, meaningful, value for
* v->processor will be chosen, and during actual domain unpause that
- * the vCPU will be assigned to and added to the proper runqueue.
+ * the unit will be assigned to and added to the proper runqueue.
*/
if ( unlikely(!cpumask_test_cpu(new_cpu, cpupool_domain_cpumask(d))) )
{
ASSERT(system_state == SYS_STATE_suspend);
- if ( vcpu_on_runq(svc) )
+ if ( unit_on_runq(svc) )
{
runq_remove(svc);
update_load(ops, svc->rqd, NULL, -1, now);
}
_runq_deassign(svc);
- vc->processor = new_cpu;
- unit->res = get_sched_res(new_cpu);
+ sched_set_res(unit, get_sched_res(new_cpu));
return;
}
@@ -2791,17 +2784,14 @@ csched2_unit_migrate(
* Do the actual movement toward new_cpu, and update vc->processor.
* If we are changing runqueue, migrate() takes care of everything.
* If we are not changing runqueue, we need to update vc->processor
- * here. In fact, if, for instance, we are here because the vcpu's
+ * here. In fact, if, for instance, we are here because the unit's
* hard affinity changed, we don't want to risk leaving vc->processor
* pointing to a pcpu where we can't run any longer.
*/
if ( trqd != svc->rqd )
migrate(ops, svc, trqd, now);
else
- {
- vc->processor = new_cpu;
- unit->res = get_sched_res(new_cpu);
- }
+ sched_set_res(unit, get_sched_res(new_cpu));
}
static int
@@ -2813,18 +2803,18 @@ csched2_dom_cntl(
struct csched2_dom * const sdom = csched2_dom(d);
struct csched2_private *prv = csched2_priv(ops);
unsigned long flags;
- struct vcpu *v;
+ struct sched_unit *unit;
int rc = 0;
/*
* Locking:
* - we must take the private lock for accessing the weights of the
- * vcpus of d, and/or the cap;
+ * units of d, and/or the cap;
* - in the putinfo case, we also need the runqueue lock(s), for
* updating the max waight of the runqueue(s).
* If changing the cap, we also need the budget_lock, for updating
* the value of the domain budget pool (and the runqueue lock,
- * for adjusting the parameters and rescheduling any vCPU that is
+ * for adjusting the parameters and rescheduling any unit that is
* running at the time of the change).
*/
switch ( op->cmd )
@@ -2846,18 +2836,18 @@ csched2_dom_cntl(
sdom->weight = op->u.credit2.weight;
- /* Update weights for vcpus, and max_weight for runqueues on which they reside */
- for_each_vcpu ( d, v )
+ /* Update weights for units, and max_weight for runqueues on which they reside */
+ for_each_sched_unit ( d, unit )
{
- struct csched2_unit *svc = csched2_unit(v->sched_unit);
- spinlock_t *lock = unit_schedule_lock(svc->vcpu->sched_unit);
+ struct csched2_unit *svc = csched2_unit(unit);
+ spinlock_t *lock = unit_schedule_lock(unit);
- ASSERT(svc->rqd == c2rqd(ops, svc->vcpu->processor));
+ ASSERT(svc->rqd == c2rqd(ops, sched_unit_cpu(unit)));
svc->weight = sdom->weight;
update_max_weight(svc->rqd, svc->weight, old_weight);
- unit_schedule_unlock(lock, svc->vcpu->sched_unit);
+ unit_schedule_unlock(lock, unit);
}
}
/* Cap */
@@ -2866,8 +2856,8 @@ csched2_dom_cntl(
struct csched2_unit *svc;
spinlock_t *lock;
- /* Cap is only valid if it's below 100 * nr_of_vCPUS */
- if ( op->u.credit2.cap > 100 * sdom->nr_vcpus )
+ /* Cap is only valid if it's below 100 * nr_of_units */
+ if ( op->u.credit2.cap > 100 * sdom->nr_units )
{
rc = -EINVAL;
write_unlock_irqrestore(&prv->lock, flags);
@@ -2880,23 +2870,23 @@ csched2_dom_cntl(
spin_unlock(&sdom->budget_lock);
/*
- * When trying to get some budget and run, each vCPU will grab
- * from the pool 1/N (with N = nr of vCPUs of the domain) of
- * the total budget. Roughly speaking, this means each vCPU will
+ * When trying to get some budget and run, each unit will grab
+ * from the pool 1/N (with N = nr of units of the domain) of
+ * the total budget. Roughly speaking, this means each unit will
* have at least one chance to run during every period.
*/
- for_each_vcpu ( d, v )
+ for_each_sched_unit ( d, unit )
{
- svc = csched2_unit(v->sched_unit);
- lock = unit_schedule_lock(svc->vcpu->sched_unit);
+ svc = csched2_unit(unit);
+ lock = unit_schedule_lock(unit);
/*
* Too small quotas would in theory cause a lot of overhead,
* which then won't happen because, in csched2_runtime(),
* CSCHED2_MIN_TIMER is what would be used anyway.
*/
- svc->budget_quota = max(sdom->tot_budget / sdom->nr_vcpus,
+ svc->budget_quota = max(sdom->tot_budget / sdom->nr_units,
CSCHED2_MIN_TIMER);
- unit_schedule_unlock(lock, svc->vcpu->sched_unit);
+ unit_schedule_unlock(lock, unit);
}
if ( sdom->cap == 0 )
@@ -2906,7 +2896,7 @@ csched2_dom_cntl(
* and queue its first replenishment event.
*
* Since cap is currently disabled for this domain, we
- * know no vCPU is messing with the domain's budget, and
+ * know no unit is messing with the domain's budget, and
* the replenishment timer is still off.
* For these reasons, it is safe to do the following without
* taking the budget_lock.
@@ -2916,42 +2906,42 @@ csched2_dom_cntl(
set_timer(&sdom->repl_timer, sdom->next_repl);
/*
- * Now, let's enable budget accounting for all the vCPUs.
+ * Now, let's enable budget accounting for all the units.
* For making sure that they will start to honour the domain's
* cap, we set their budget to 0.
* This way, as soon as they will try to run, they will have
* to get some budget.
*
- * For the vCPUs that are already running, we trigger the
+ * For the units that are already running, we trigger the
* scheduler on their pCPU. When, as a consequence of this,
* csched2_schedule() will run, it will figure out there is
- * no budget, and the vCPU will try to get some (and be parked,
+ * no budget, and the unit will try to get some (and be parked,
* if there's none, and we'll switch to someone else).
*/
- for_each_vcpu ( d, v )
+ for_each_sched_unit ( d, unit )
{
- svc = csched2_unit(v->sched_unit);
- lock = unit_schedule_lock(svc->vcpu->sched_unit);
- if ( v->sched_unit->is_running )
+ svc = csched2_unit(unit);
+ lock = unit_schedule_lock(unit);
+ if ( unit->is_running )
{
- unsigned int cpu = v->processor;
+ unsigned int cpu = sched_unit_cpu(unit);
struct csched2_runqueue_data *rqd = c2rqd(ops, cpu);
- ASSERT(curr_on_cpu(cpu)->vcpu_list == v);
+ ASSERT(curr_on_cpu(cpu) == unit);
/*
- * We are triggering a reschedule on the vCPU's
+ * We are triggering a reschedule on the unit's
* pCPU. That will run burn_credits() and, since
- * the vCPU is capped now, it would charge all the
+ * the unit is capped now, it would charge all the
* execution time of this last round as budget as
- * well. That will make the vCPU budget go negative,
+ * well. That will make the unit budget go negative,
* potentially by a large amount, and it's unfair.
*
* To avoid that, call burn_credit() here, to do the
* accounting of this current running instance now,
* with budgetting still disabled. This does not
* prevent some small amount of budget being charged
- * to the vCPU (i.e., the amount of time it runs from
+ * to the unit (i.e., the amount of time it runs from
* now, to when scheduling happens). The budget will
* also go below 0, but a lot less than how it would
* if we don't do this.
@@ -2962,7 +2952,7 @@ csched2_dom_cntl(
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
}
svc->budget = 0;
- unit_schedule_unlock(lock, svc->vcpu->sched_unit);
+ unit_schedule_unlock(lock, unit);
}
}
@@ -2974,30 +2964,30 @@ csched2_dom_cntl(
stop_timer(&sdom->repl_timer);
- /* Disable budget accounting for all the vCPUs. */
- for_each_vcpu ( d, v )
+ /* Disable budget accounting for all the units. */
+ for_each_sched_unit ( d, unit )
{
- struct csched2_unit *svc = csched2_unit(v->sched_unit);
- spinlock_t *lock = unit_schedule_lock(svc->vcpu->sched_unit);
+ struct csched2_unit *svc = csched2_unit(unit);
+ spinlock_t *lock = unit_schedule_lock(unit);
svc->budget = STIME_MAX;
svc->budget_quota = 0;
- unit_schedule_unlock(lock, svc->vcpu->sched_unit);
+ unit_schedule_unlock(lock, unit);
}
sdom->cap = 0;
/*
* We are disabling the cap for this domain, which may have
- * vCPUs waiting for a replenishment, so we unpark them all.
+ * units waiting for a replenishment, so we unpark them all.
* Note that, since we have already disabled budget accounting
- * for all the vCPUs of the domain, no currently running vCPU
- * will be added to the parked vCPUs list any longer.
+ * for all the units of the domain, no currently running unit
+ * will be added to the parked units list any longer.
*/
spin_lock(&sdom->budget_lock);
- list_splice_init(&sdom->parked_vcpus, &parked);
+ list_splice_init(&sdom->parked_units, &parked);
spin_unlock(&sdom->budget_lock);
- unpark_parked_vcpus(ops, &parked);
+ unpark_parked_units(ops, &parked);
}
write_unlock_irqrestore(&prv->lock, flags);
break;
@@ -3074,12 +3064,12 @@ csched2_alloc_domdata(const struct scheduler *ops, struct domain *dom)
sdom->dom = dom;
sdom->weight = CSCHED2_DEFAULT_WEIGHT;
sdom->cap = 0U;
- sdom->nr_vcpus = 0;
+ sdom->nr_units = 0;
init_timer(&sdom->repl_timer, replenish_domain_budget, sdom,
cpumask_any(cpupool_domain_cpumask(dom)));
spin_lock_init(&sdom->budget_lock);
- INIT_LIST_HEAD(&sdom->parked_vcpus);
+ INIT_LIST_HEAD(&sdom->parked_units);
write_lock_irqsave(&prv->lock, flags);
@@ -3113,34 +3103,32 @@ csched2_free_domdata(const struct scheduler *ops, void *data)
static void
csched2_unit_insert(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched2_unit *svc = unit->priv;
struct csched2_dom * const sdom = svc->sdom;
spinlock_t *lock;
- ASSERT(!is_idle_vcpu(vc));
+ ASSERT(!is_idle_unit(unit));
ASSERT(list_empty(&svc->runq_elem));
/* csched2_res_pick() expects the pcpu lock to be held */
lock = unit_schedule_lock_irq(unit);
- unit->res = csched2_res_pick(ops, unit);
- vc->processor = unit->res->master_cpu;
+ sched_set_res(unit, csched2_res_pick(ops, unit));
spin_unlock_irq(lock);
lock = unit_schedule_lock_irq(unit);
- /* Add vcpu to runqueue of initial processor */
- runq_assign(ops, vc);
+ /* Add unit to runqueue of initial processor */
+ runq_assign(ops, unit);
unit_schedule_unlock_irq(lock, unit);
- sdom->nr_vcpus++;
+ sdom->nr_units++;
SCHED_STAT_CRANK(unit_insert);
- CSCHED2_VCPU_CHECK(vc);
+ CSCHED2_UNIT_CHECK(unit);
}
static void
@@ -3154,11 +3142,10 @@ csched2_free_vdata(const struct scheduler *ops, void *priv)
static void
csched2_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
struct csched2_unit * const svc = csched2_unit(unit);
spinlock_t *lock;
- ASSERT(!is_idle_vcpu(vc));
+ ASSERT(!is_idle_unit(unit));
ASSERT(list_empty(&svc->runq_elem));
SCHED_STAT_CRANK(unit_remove);
@@ -3166,14 +3153,14 @@ csched2_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
/* Remove from runqueue */
lock = unit_schedule_lock_irq(unit);
- runq_deassign(ops, vc);
+ runq_deassign(ops, unit);
unit_schedule_unlock_irq(lock, unit);
- svc->sdom->nr_vcpus--;
+ svc->sdom->nr_units--;
}
-/* How long should we let this vcpu run for? */
+/* How long should we let this unit run for? */
static s_time_t
csched2_runtime(const struct scheduler *ops, int cpu,
struct csched2_unit *snext, s_time_t now)
@@ -3188,7 +3175,7 @@ csched2_runtime(const struct scheduler *ops, int cpu,
* If we're idle, just stay so. Others (or external events)
* will poke us when necessary.
*/
- if ( is_idle_vcpu(snext->vcpu) )
+ if ( is_idle_unit(snext->unit) )
return -1;
/* General algorithm:
@@ -3205,8 +3192,8 @@ csched2_runtime(const struct scheduler *ops, int cpu,
if ( prv->ratelimit_us )
{
s_time_t ratelimit_min = MICROSECS(prv->ratelimit_us);
- if ( snext->vcpu->sched_unit->is_running )
- ratelimit_min = snext->vcpu->sched_unit->state_entry_time +
+ if ( snext->unit->is_running )
+ ratelimit_min = snext->unit->state_entry_time +
MICROSECS(prv->ratelimit_us) - now;
if ( ratelimit_min > min_time )
min_time = ratelimit_min;
@@ -3223,7 +3210,7 @@ csched2_runtime(const struct scheduler *ops, int cpu,
{
struct csched2_unit *swait = runq_elem(runq->next);
- if ( ! is_idle_vcpu(swait->vcpu)
+ if ( ! is_idle_unit(swait->unit)
&& swait->credit > 0 )
{
rt_credit = snext->credit - swait->credit;
@@ -3237,7 +3224,7 @@ csched2_runtime(const struct scheduler *ops, int cpu,
*
* FIXME: See if we can eliminate this conversion if we know time
* will be outside (MIN,MAX). Probably requires pre-calculating
- * credit values of MIN,MAX per vcpu, since each vcpu burns credit
+ * credit values of MIN,MAX per unit, since each unit burns credit
* at a different rate.
*/
if ( rt_credit > 0 )
@@ -3285,36 +3272,35 @@ runq_candidate(struct csched2_runqueue_data *rqd,
*skipped = 0;
- if ( unlikely(is_idle_vcpu(scurr->vcpu)) )
+ if ( unlikely(is_idle_unit(scurr->unit)) )
{
snext = scurr;
goto check_runq;
}
- yield = __test_and_clear_bit(__CSFLAG_vcpu_yield, &scurr->flags);
+ yield = __test_and_clear_bit(__CSFLAG_unit_yield, &scurr->flags);
/*
- * Return the current vcpu if it has executed for less than ratelimit.
- * Adjuststment for the selected vcpu's credit and decision
+ * Return the current unit if it has executed for less than ratelimit.
+ * Adjuststment for the selected unit's credit and decision
* for how long it will run will be taken in csched2_runtime.
*
* Note that, if scurr is yielding, we don't let rate limiting kick in.
* In fact, it may be the case that scurr is about to spin, and there's
* no point forcing it to do so until rate limiting expires.
*/
- if ( !yield && prv->ratelimit_us && vcpu_runnable(scurr->vcpu) &&
- (now - scurr->vcpu->sched_unit->state_entry_time) <
- MICROSECS(prv->ratelimit_us) )
+ if ( !yield && prv->ratelimit_us && unit_runnable(scurr->unit) &&
+ (now - scurr->unit->state_entry_time) < MICROSECS(prv->ratelimit_us) )
{
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
unsigned runtime;
} d;
- d.dom = scurr->vcpu->domain->domain_id;
- d.vcpu = scurr->vcpu->vcpu_id;
- d.runtime = now - scurr->vcpu->sched_unit->state_entry_time;
+ d.dom = scurr->unit->domain->domain_id;
+ d.unit = scurr->unit->unit_id;
+ d.runtime = now - scurr->unit->state_entry_time;
__trace_var(TRC_CSCHED2_RATELIMIT, 1,
sizeof(d),
(unsigned char *)&d);
@@ -3323,13 +3309,13 @@ runq_candidate(struct csched2_runqueue_data *rqd,
}
/* If scurr has a soft-affinity, let's check whether cpu is part of it */
- if ( has_soft_affinity(scurr->vcpu->sched_unit) )
+ if ( has_soft_affinity(scurr->unit) )
{
- affinity_balance_cpumask(scurr->vcpu->sched_unit, BALANCE_SOFT_AFFINITY,
+ affinity_balance_cpumask(scurr->unit, BALANCE_SOFT_AFFINITY,
cpumask_scratch);
if ( unlikely(!cpumask_test_cpu(cpu, cpumask_scratch)) )
{
- cpumask_t *online = cpupool_domain_cpumask(scurr->vcpu->domain);
+ cpumask_t *online = cpupool_domain_cpumask(scurr->unit->domain);
/* Ok, is any of the pcpus in scurr soft-affinity idle? */
cpumask_and(cpumask_scratch, cpumask_scratch, &rqd->idle);
@@ -3357,10 +3343,10 @@ runq_candidate(struct csched2_runqueue_data *rqd,
*
* Of course, we also default to idle also if scurr is not runnable.
*/
- if ( vcpu_runnable(scurr->vcpu) && !soft_aff_preempt )
+ if ( unit_runnable(scurr->unit) && !soft_aff_preempt )
snext = scurr;
else
- snext = csched2_unit(idle_vcpu[cpu]->sched_unit);
+ snext = csched2_unit(sched_idle_unit(cpu));
check_runq:
list_for_each_safe( iter, temp, &rqd->runq )
@@ -3370,24 +3356,24 @@ runq_candidate(struct csched2_runqueue_data *rqd,
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
} d;
- d.dom = svc->vcpu->domain->domain_id;
- d.vcpu = svc->vcpu->vcpu_id;
+ d.dom = svc->unit->domain->domain_id;
+ d.unit = svc->unit->unit_id;
__trace_var(TRC_CSCHED2_RUNQ_CAND_CHECK, 1,
sizeof(d),
(unsigned char *)&d);
}
- /* Only consider vcpus that are allowed to run on this processor. */
- if ( !cpumask_test_cpu(cpu, svc->vcpu->sched_unit->cpu_hard_affinity) )
+ /* Only consider units that are allowed to run on this processor. */
+ if ( !cpumask_test_cpu(cpu, svc->unit->cpu_hard_affinity) )
{
(*skipped)++;
continue;
}
/*
- * If a vcpu is meant to be picked up by another processor, and such
+ * If an unit is meant to be picked up by another processor, and such
* processor has not scheduled yet, leave it in the runqueue for him.
*/
if ( svc->tickled_cpu != -1 && svc->tickled_cpu != cpu &&
@@ -3402,7 +3388,7 @@ runq_candidate(struct csched2_runqueue_data *rqd,
* If this is on a different processor, don't pull it unless
* its credit is at least CSCHED2_MIGRATE_RESIST higher.
*/
- if ( svc->vcpu->processor != cpu
+ if ( sched_unit_cpu(svc->unit) != cpu
&& snext->credit + CSCHED2_MIGRATE_RESIST > svc->credit )
{
(*skipped)++;
@@ -3417,7 +3403,7 @@ runq_candidate(struct csched2_runqueue_data *rqd,
* some budget, then choose it.
*/
if ( (yield || svc->credit > snext->credit) &&
- (!has_cap(svc) || vcpu_grab_budget(svc)) )
+ (!has_cap(svc) || unit_grab_budget(svc)) )
snext = svc;
/* In any case, if we got this far, break. */
@@ -3427,12 +3413,12 @@ runq_candidate(struct csched2_runqueue_data *rqd,
if ( unlikely(tb_init_done) )
{
struct {
- unsigned vcpu:16, dom:16;
+ unsigned unit:16, dom:16;
unsigned tickled_cpu, skipped;
int credit;
} d;
- d.dom = snext->vcpu->domain->domain_id;
- d.vcpu = snext->vcpu->vcpu_id;
+ d.dom = snext->unit->domain->domain_id;
+ d.unit = snext->unit->unit_id;
d.credit = snext->credit;
d.tickled_cpu = snext->tickled_cpu;
d.skipped = *skipped;
@@ -3464,14 +3450,15 @@ csched2_schedule(
{
const int cpu = smp_processor_id();
struct csched2_runqueue_data *rqd;
- struct csched2_unit * const scurr = csched2_unit(current->sched_unit);
+ struct sched_unit *currunit = current->sched_unit;
+ struct csched2_unit * const scurr = csched2_unit(currunit);
struct csched2_unit *snext = NULL;
- unsigned int skipped_vcpus = 0;
+ unsigned int skipped_units = 0;
struct task_slice ret;
bool tickled;
SCHED_STAT_CRANK(schedule);
- CSCHED2_VCPU_CHECK(current);
+ CSCHED2_UNIT_CHECK(currunit);
BUG_ON(!cpumask_test_cpu(cpu, &csched2_priv(ops)->initialized));
@@ -3480,7 +3467,7 @@ csched2_schedule(
ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
- BUG_ON(!is_idle_vcpu(scurr->vcpu) && scurr->rqd != rqd);
+ BUG_ON(!is_idle_unit(currunit) && scurr->rqd != rqd);
/* Clear "tickled" bit now that we've been scheduled */
tickled = cpumask_test_cpu(cpu, &rqd->tickled);
@@ -3500,7 +3487,7 @@ csched2_schedule(
d.cpu = cpu;
d.rq_id = c2r(cpu);
d.tasklet = tasklet_work_scheduled;
- d.idle = is_idle_vcpu(current);
+ d.idle = is_idle_unit(currunit);
d.smt_idle = cpumask_test_cpu(cpu, &rqd->smt_idle);
d.tickled = tickled;
__trace_var(TRC_CSCHED2_SCHEDULE, 1,
@@ -3514,55 +3501,55 @@ csched2_schedule(
/*
* Below 0, means that we are capped and we have overrun our budget.
* Let's try to get some more but, if we fail (e.g., because of the
- * other running vcpus), we will be parked.
+ * other running units), we will be parked.
*/
if ( unlikely(scurr->budget <= 0) )
- vcpu_grab_budget(scurr);
+ unit_grab_budget(scurr);
/*
- * Select next runnable local VCPU (ie top of local runq).
+ * Select next runnable local UNIT (ie top of local runq).
*
- * If the current vcpu is runnable, and has higher credit than
+ * If the current unit is runnable, and has higher credit than
* the next guy on the queue (or there is noone else), we want to
* run him again.
*
- * If there's tasklet work to do, we want to chose the idle vcpu
+ * If there's tasklet work to do, we want to chose the idle unit
* for this processor, and mark the current for delayed runqueue
* add.
*
- * If the current vcpu is runnable, and there's another runnable
+ * If the current unit is runnable, and there's another runnable
* candidate, we want to mark current for delayed runqueue add,
* and remove the next guy from the queue.
*
- * If the current vcpu is not runnable, we want to chose the idle
- * vcpu for this processor.
+ * If the current unit is not runnable, we want to chose the idle
+ * unit for this processor.
*/
if ( tasklet_work_scheduled )
{
- __clear_bit(__CSFLAG_vcpu_yield, &scurr->flags);
+ __clear_bit(__CSFLAG_unit_yield, &scurr->flags);
trace_var(TRC_CSCHED2_SCHED_TASKLET, 1, 0, NULL);
- snext = csched2_unit(idle_vcpu[cpu]->sched_unit);
+ snext = csched2_unit(sched_idle_unit(cpu));
}
else
- snext = runq_candidate(rqd, scurr, cpu, now, &skipped_vcpus);
+ snext = runq_candidate(rqd, scurr, cpu, now, &skipped_units);
- /* If switching from a non-idle runnable vcpu, put it
+ /* If switching from a non-idle runnable unit, put it
* back on the runqueue. */
if ( snext != scurr
- && !is_idle_vcpu(scurr->vcpu)
- && vcpu_runnable(current) )
+ && !is_idle_unit(currunit)
+ && unit_runnable(currunit) )
__set_bit(__CSFLAG_delayed_runq_add, &scurr->flags);
ret.migrated = 0;
/* Accounting for non-idle tasks */
- if ( !is_idle_vcpu(snext->vcpu) )
+ if ( !is_idle_unit(snext->unit) )
{
/* If switching, remove this from the runqueue and mark it scheduled */
if ( snext != scurr )
{
ASSERT(snext->rqd == rqd);
- ASSERT(!snext->vcpu->sched_unit->is_running);
+ ASSERT(!snext->unit->is_running);
runq_remove(snext);
__set_bit(__CSFLAG_scheduled, &snext->flags);
@@ -3577,19 +3564,19 @@ csched2_schedule(
/*
* The reset condition is "has a scheduler epoch come to an end?".
- * The way this is enforced is checking whether the vcpu at the top
+ * The way this is enforced is checking whether the unit at the top
* of the runqueue has negative credits. This means the epochs have
* variable length, as in one epoch expores when:
- * 1) the vcpu at the top of the runqueue has executed for
+ * 1) the unit at the top of the runqueue has executed for
* around 10 ms (with default parameters);
- * 2) no other vcpu with higher credits wants to run.
+ * 2) no other unit with higher credits wants to run.
*
* Here, where we want to check for reset, we need to make sure the
- * proper vcpu is being used. In fact, runqueue_candidate() may have
- * not returned the first vcpu in the runqueue, for various reasons
+ * proper unit is being used. In fact, runqueue_candidate() may have
+ * not returned the first unit in the runqueue, for various reasons
* (e.g., affinity). Only trigger a reset when it does.
*/
- if ( skipped_vcpus == 0 && snext->credit <= CSCHED2_CREDIT_RESET )
+ if ( skipped_units == 0 && snext->credit <= CSCHED2_CREDIT_RESET )
{
reset_credit(ops, cpu, now, snext);
balance_load(ops, cpu, now);
@@ -3599,11 +3586,10 @@ csched2_schedule(
snext->tickled_cpu = -1;
/* Safe because lock for old processor is held */
- if ( snext->vcpu->processor != cpu )
+ if ( sched_unit_cpu(snext->unit) != cpu )
{
snext->credit += CSCHED2_MIGRATE_COMPENSATION;
- snext->vcpu->processor = cpu;
- snext->vcpu->sched_unit->res = get_sched_res(cpu);
+ sched_set_res(snext->unit, get_sched_res(cpu));
SCHED_STAT_CRANK(migrated);
ret.migrated = 1;
}
@@ -3637,20 +3623,20 @@ csched2_schedule(
* Return task to run next...
*/
ret.time = csched2_runtime(ops, cpu, snext, now);
- ret.task = snext->vcpu->sched_unit;
+ ret.task = snext->unit;
- CSCHED2_VCPU_CHECK(ret.task->vcpu_list);
+ CSCHED2_UNIT_CHECK(ret.task);
return ret;
}
static void
-csched2_dump_vcpu(struct csched2_private *prv, struct csched2_unit *svc)
+csched2_dump_unit(struct csched2_private *prv, struct csched2_unit *svc)
{
printk("[%i.%i] flags=%x cpu=%i",
- svc->vcpu->domain->domain_id,
- svc->vcpu->vcpu_id,
+ svc->unit->domain->domain_id,
+ svc->unit->unit_id,
svc->flags,
- svc->vcpu->processor);
+ sched_unit_cpu(svc->unit));
printk(" credit=%" PRIi32" [w=%u]", svc->credit, svc->weight);
@@ -3675,12 +3661,12 @@ dump_pcpu(const struct scheduler *ops, int cpu)
CPUMASK_PR(per_cpu(cpu_sibling_mask, cpu)),
CPUMASK_PR(per_cpu(cpu_core_mask, cpu)));
- /* current VCPU (nothing to say if that's the idle vcpu) */
+ /* current UNIT (nothing to say if that's the idle unit) */
svc = csched2_unit(curr_on_cpu(cpu));
- if ( svc && !is_idle_vcpu(svc->vcpu) )
+ if ( svc && !is_idle_unit(svc->unit) )
{
printk("\trun: ");
- csched2_dump_vcpu(prv, svc);
+ csched2_dump_unit(prv, svc);
}
}
@@ -3737,7 +3723,7 @@ csched2_dump(const struct scheduler *ops)
list_for_each( iter_sdom, &prv->sdom )
{
struct csched2_dom *sdom;
- struct vcpu *v;
+ struct sched_unit *unit;
sdom = list_entry(iter_sdom, struct csched2_dom, sdom_elem);
@@ -3745,19 +3731,19 @@ csched2_dump(const struct scheduler *ops)
sdom->dom->domain_id,
sdom->weight,
sdom->cap,
- sdom->nr_vcpus);
+ sdom->nr_units);
- for_each_vcpu( sdom->dom, v )
+ for_each_sched_unit ( sdom->dom, unit )
{
- struct csched2_unit * const svc = csched2_unit(v->sched_unit);
+ struct csched2_unit * const svc = csched2_unit(unit);
spinlock_t *lock;
- lock = unit_schedule_lock(svc->vcpu->sched_unit);
+ lock = unit_schedule_lock(unit);
printk("\t%3d: ", ++loop);
- csched2_dump_vcpu(prv, svc);
+ csched2_dump_unit(prv, svc);
- unit_schedule_unlock(lock, svc->vcpu->sched_unit);
+ unit_schedule_unlock(lock, unit);
}
}
@@ -3783,7 +3769,7 @@ csched2_dump(const struct scheduler *ops)
if ( svc )
{
printk("\t%3d: ", loop++);
- csched2_dump_vcpu(prv, svc);
+ csched2_dump_unit(prv, svc);
}
}
spin_unlock(&rqd->lock);
@@ -3886,7 +3872,7 @@ csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu,
struct sched_resource *sd = get_sched_res(cpu);
unsigned rqi;
- ASSERT(pdata && svc && is_idle_vcpu(svc->vcpu));
+ ASSERT(pdata && svc && is_idle_unit(svc->unit));
/*
* We own one runqueue lock already (from schedule_cpu_switch()). This
@@ -3899,7 +3885,7 @@ csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu,
ASSERT(!local_irq_is_enabled());
write_lock(&prv->lock);
- idle_vcpu[cpu]->sched_unit->priv = vdata;
+ sched_idle_unit(cpu)->priv = vdata;
rqi = init_pdata(prv, pdata, cpu);
@@ -3941,7 +3927,7 @@ csched2_deinit_pdata(const struct scheduler *ops, void *pcpu, int cpu)
*/
ASSERT(spc && spc->runq_id != -1);
ASSERT(cpumask_test_cpu(cpu, &prv->initialized));
-
+
/* Find the old runqueue and remove this cpu from it */
rqd = prv->rqd + spc->runq_id;
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 18/47] xen/sched: make arinc653 scheduler vcpu agnostic.
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (16 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 17/47] xen/sched: make credit2 " Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-25 13:51 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 19/47] xen: add sched_unit_pause_nosync() and sched_unit_unpause() Juergen Gross
` (30 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, George Dunlap, Josh Whitehead, Robert VanVossen,
Dario Faggioli
Switch arinc653 scheduler completely from vcpu to sched_unit usage.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/sched_arinc653.c | 208 +++++++++++++++++++++-----------------------
1 file changed, 101 insertions(+), 107 deletions(-)
diff --git a/xen/common/sched_arinc653.c b/xen/common/sched_arinc653.c
index 6ae5924980..8c431e6edd 100644
--- a/xen/common/sched_arinc653.c
+++ b/xen/common/sched_arinc653.c
@@ -45,15 +45,15 @@
#define DEFAULT_TIMESLICE MILLISECS(10)
/**
- * Retrieve the idle VCPU for a given physical CPU
+ * Retrieve the idle UNIT for a given physical CPU
*/
-#define IDLETASK(cpu) (idle_vcpu[cpu])
+#define IDLETASK(cpu) (sched_idle_unit(cpu))
/**
* Return a pointer to the ARINC 653-specific scheduler data information
- * associated with the given VCPU (vc)
+ * associated with the given UNIT (unit)
*/
-#define AVCPU(vc) ((arinc653_vcpu_t *)(vc)->sched_unit->priv)
+#define AUNIT(unit) ((arinc653_unit_t *)(unit)->priv)
/**
* Return the global scheduler private data given the scheduler ops pointer
@@ -65,20 +65,20 @@
**************************************************************************/
/**
- * The arinc653_vcpu_t structure holds ARINC 653-scheduler-specific
- * information for all non-idle VCPUs
+ * The arinc653_unit_t structure holds ARINC 653-scheduler-specific
+ * information for all non-idle UNITs
*/
-typedef struct arinc653_vcpu_s
+typedef struct arinc653_unit_s
{
- /* vc points to Xen's struct vcpu so we can get to it from an
- * arinc653_vcpu_t pointer. */
- struct vcpu * vc;
- /* awake holds whether the VCPU has been woken with vcpu_wake() */
+ /* unit points to Xen's struct sched_unit so we can get to it from an
+ * arinc653_unit_t pointer. */
+ struct sched_unit * unit;
+ /* awake holds whether the UNIT has been woken with vcpu_wake() */
bool_t awake;
- /* list holds the linked list information for the list this VCPU
+ /* list holds the linked list information for the list this UNIT
* is stored in */
struct list_head list;
-} arinc653_vcpu_t;
+} arinc653_unit_t;
/**
* The sched_entry_t structure holds a single entry of the
@@ -89,14 +89,14 @@ typedef struct sched_entry_s
/* dom_handle holds the handle ("UUID") for the domain that this
* schedule entry refers to. */
xen_domain_handle_t dom_handle;
- /* vcpu_id holds the VCPU number for the VCPU that this schedule
+ /* unit_id holds the UNIT number for the UNIT that this schedule
* entry refers to. */
- int vcpu_id;
- /* runtime holds the number of nanoseconds that the VCPU for this
+ int unit_id;
+ /* runtime holds the number of nanoseconds that the UNIT for this
* schedule entry should be allowed to run per major frame. */
s_time_t runtime;
- /* vc holds a pointer to the Xen VCPU structure */
- struct vcpu * vc;
+ /* unit holds a pointer to the Xen sched_unit structure */
+ struct sched_unit * unit;
} sched_entry_t;
/**
@@ -110,9 +110,9 @@ typedef struct a653sched_priv_s
/**
* This array holds the active ARINC 653 schedule.
*
- * When the system tries to start a new VCPU, this schedule is scanned
- * to look for a matching (handle, VCPU #) pair. If both the handle (UUID)
- * and VCPU number match, then the VCPU is allowed to run. Its run time
+ * When the system tries to start a new UNIT, this schedule is scanned
+ * to look for a matching (handle, UNIT #) pair. If both the handle (UUID)
+ * and UNIT number match, then the UNIT is allowed to run. Its run time
* (per major frame) is given in the third entry of the schedule.
*/
sched_entry_t schedule[ARINC653_MAX_DOMAINS_PER_SCHEDULE];
@@ -123,8 +123,8 @@ typedef struct a653sched_priv_s
*
* This is not necessarily the same as the number of domains in the
* schedule. A domain could be listed multiple times within the schedule,
- * or a domain with multiple VCPUs could have a different
- * schedule entry for each VCPU.
+ * or a domain with multiple UNITs could have a different
+ * schedule entry for each UNIT.
*/
unsigned int num_schedule_entries;
@@ -139,9 +139,9 @@ typedef struct a653sched_priv_s
s_time_t next_major_frame;
/**
- * pointers to all Xen VCPU structures for iterating through
+ * pointers to all Xen UNIT structures for iterating through
*/
- struct list_head vcpu_list;
+ struct list_head unit_list;
} a653sched_priv_t;
/**************************************************************************
@@ -167,50 +167,50 @@ static int dom_handle_cmp(const xen_domain_handle_t h1,
}
/**
- * This function searches the vcpu list to find a VCPU that matches
- * the domain handle and VCPU ID specified.
+ * This function searches the unit list to find a UNIT that matches
+ * the domain handle and UNIT ID specified.
*
* @param ops Pointer to this instance of the scheduler structure
* @param handle Pointer to handler
- * @param vcpu_id VCPU ID
+ * @param unit_id UNIT ID
*
* @return <ul>
- * <li> Pointer to the matching VCPU if one is found
+ * <li> Pointer to the matching UNIT if one is found
* <li> NULL otherwise
* </ul>
*/
-static struct vcpu *find_vcpu(
+static struct sched_unit *find_unit(
const struct scheduler *ops,
xen_domain_handle_t handle,
- int vcpu_id)
+ int unit_id)
{
- arinc653_vcpu_t *avcpu;
+ arinc653_unit_t *aunit;
- /* loop through the vcpu_list looking for the specified VCPU */
- list_for_each_entry ( avcpu, &SCHED_PRIV(ops)->vcpu_list, list )
- if ( (dom_handle_cmp(avcpu->vc->domain->handle, handle) == 0)
- && (vcpu_id == avcpu->vc->vcpu_id) )
- return avcpu->vc;
+ /* loop through the unit_list looking for the specified UNIT */
+ list_for_each_entry ( aunit, &SCHED_PRIV(ops)->unit_list, list )
+ if ( (dom_handle_cmp(aunit->unit->domain->handle, handle) == 0)
+ && (unit_id == aunit->unit->unit_id) )
+ return aunit->unit;
return NULL;
}
/**
- * This function updates the pointer to the Xen VCPU structure for each entry
+ * This function updates the pointer to the Xen UNIT structure for each entry
* in the ARINC 653 schedule.
*
* @param ops Pointer to this instance of the scheduler structure
* @return <None>
*/
-static void update_schedule_vcpus(const struct scheduler *ops)
+static void update_schedule_units(const struct scheduler *ops)
{
unsigned int i, n_entries = SCHED_PRIV(ops)->num_schedule_entries;
for ( i = 0; i < n_entries; i++ )
- SCHED_PRIV(ops)->schedule[i].vc =
- find_vcpu(ops,
+ SCHED_PRIV(ops)->schedule[i].unit =
+ find_unit(ops,
SCHED_PRIV(ops)->schedule[i].dom_handle,
- SCHED_PRIV(ops)->schedule[i].vcpu_id);
+ SCHED_PRIV(ops)->schedule[i].unit_id);
}
/**
@@ -268,12 +268,12 @@ arinc653_sched_set(
memcpy(sched_priv->schedule[i].dom_handle,
schedule->sched_entries[i].dom_handle,
sizeof(sched_priv->schedule[i].dom_handle));
- sched_priv->schedule[i].vcpu_id =
+ sched_priv->schedule[i].unit_id =
schedule->sched_entries[i].vcpu_id;
sched_priv->schedule[i].runtime =
schedule->sched_entries[i].runtime;
}
- update_schedule_vcpus(ops);
+ update_schedule_units(ops);
/*
* The newly-installed schedule takes effect immediately. We do not even
@@ -319,7 +319,7 @@ arinc653_sched_get(
memcpy(schedule->sched_entries[i].dom_handle,
sched_priv->schedule[i].dom_handle,
sizeof(sched_priv->schedule[i].dom_handle));
- schedule->sched_entries[i].vcpu_id = sched_priv->schedule[i].vcpu_id;
+ schedule->sched_entries[i].vcpu_id = sched_priv->schedule[i].unit_id;
schedule->sched_entries[i].runtime = sched_priv->schedule[i].runtime;
}
@@ -355,7 +355,7 @@ a653sched_init(struct scheduler *ops)
prv->next_major_frame = 0;
spin_lock_init(&prv->lock);
- INIT_LIST_HEAD(&prv->vcpu_list);
+ INIT_LIST_HEAD(&prv->unit_list);
return 0;
}
@@ -373,7 +373,7 @@ a653sched_deinit(struct scheduler *ops)
}
/**
- * This function allocates scheduler-specific data for a VCPU
+ * This function allocates scheduler-specific data for a UNIT
*
* @param ops Pointer to this instance of the scheduler structure
* @param unit Pointer to struct sched_unit
@@ -385,35 +385,34 @@ a653sched_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
void *dd)
{
a653sched_priv_t *sched_priv = SCHED_PRIV(ops);
- struct vcpu *vc = unit->vcpu_list;
- arinc653_vcpu_t *svc;
+ arinc653_unit_t *svc;
unsigned int entry;
unsigned long flags;
/*
* Allocate memory for the ARINC 653-specific scheduler data information
- * associated with the given VCPU (vc).
+ * associated with the given UNIT (unit).
*/
- svc = xmalloc(arinc653_vcpu_t);
+ svc = xmalloc(arinc653_unit_t);
if ( svc == NULL )
return NULL;
spin_lock_irqsave(&sched_priv->lock, flags);
- /*
- * Add every one of dom0's vcpus to the schedule, as long as there are
+ /*
+ * Add every one of dom0's units to the schedule, as long as there are
* slots available.
*/
- if ( vc->domain->domain_id == 0 )
+ if ( unit->domain->domain_id == 0 )
{
entry = sched_priv->num_schedule_entries;
if ( entry < ARINC653_MAX_DOMAINS_PER_SCHEDULE )
{
sched_priv->schedule[entry].dom_handle[0] = '\0';
- sched_priv->schedule[entry].vcpu_id = vc->vcpu_id;
+ sched_priv->schedule[entry].unit_id = unit->unit_id;
sched_priv->schedule[entry].runtime = DEFAULT_TIMESLICE;
- sched_priv->schedule[entry].vc = vc;
+ sched_priv->schedule[entry].unit = unit;
sched_priv->major_frame += DEFAULT_TIMESLICE;
++sched_priv->num_schedule_entries;
@@ -421,16 +420,16 @@ a653sched_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
}
/*
- * Initialize our ARINC 653 scheduler-specific information for the VCPU.
- * The VCPU starts "asleep." When Xen is ready for the VCPU to run, it
+ * Initialize our ARINC 653 scheduler-specific information for the UNIT.
+ * The UNIT starts "asleep." When Xen is ready for the UNIT to run, it
* will call the vcpu_wake scheduler callback function and our scheduler
- * will mark the VCPU awake.
+ * will mark the UNIT awake.
*/
- svc->vc = vc;
+ svc->unit = unit;
svc->awake = 0;
- if ( !is_idle_vcpu(vc) )
- list_add(&svc->list, &SCHED_PRIV(ops)->vcpu_list);
- update_schedule_vcpus(ops);
+ if ( !is_idle_unit(unit) )
+ list_add(&svc->list, &SCHED_PRIV(ops)->unit_list);
+ update_schedule_units(ops);
spin_unlock_irqrestore(&sched_priv->lock, flags);
@@ -438,27 +437,27 @@ a653sched_alloc_vdata(const struct scheduler *ops, struct sched_unit *unit,
}
/**
- * This function frees scheduler-specific VCPU data
+ * This function frees scheduler-specific UNIT data
*
* @param ops Pointer to this instance of the scheduler structure
*/
static void
a653sched_free_vdata(const struct scheduler *ops, void *priv)
{
- arinc653_vcpu_t *av = priv;
+ arinc653_unit_t *av = priv;
if (av == NULL)
return;
- if ( !is_idle_vcpu(av->vc) )
+ if ( !is_idle_unit(av->unit) )
list_del(&av->list);
xfree(av);
- update_schedule_vcpus(ops);
+ update_schedule_units(ops);
}
/**
- * Xen scheduler callback function to sleep a VCPU
+ * Xen scheduler callback function to sleep a UNIT
*
* @param ops Pointer to this instance of the scheduler structure
* @param unit Pointer to struct sched_unit
@@ -466,21 +465,19 @@ a653sched_free_vdata(const struct scheduler *ops, void *priv)
static void
a653sched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
-
- if ( AVCPU(vc) != NULL )
- AVCPU(vc)->awake = 0;
+ if ( AUNIT(unit) != NULL )
+ AUNIT(unit)->awake = 0;
/*
- * If the VCPU being put to sleep is the same one that is currently
+ * If the UNIT being put to sleep is the same one that is currently
* running, raise a softirq to invoke the scheduler to switch domains.
*/
- if ( get_sched_res(vc->processor)->curr == unit )
- cpu_raise_softirq(vc->processor, SCHEDULE_SOFTIRQ);
+ if ( get_sched_res(sched_unit_cpu(unit))->curr == unit )
+ cpu_raise_softirq(sched_unit_cpu(unit), SCHEDULE_SOFTIRQ);
}
/**
- * Xen scheduler callback function to wake up a VCPU
+ * Xen scheduler callback function to wake up a UNIT
*
* @param ops Pointer to this instance of the scheduler structure
* @param unit Pointer to struct sched_unit
@@ -488,24 +485,22 @@ a653sched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
static void
a653sched_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
+ if ( AUNIT(unit) != NULL )
+ AUNIT(unit)->awake = 1;
- if ( AVCPU(vc) != NULL )
- AVCPU(vc)->awake = 1;
-
- cpu_raise_softirq(vc->processor, SCHEDULE_SOFTIRQ);
+ cpu_raise_softirq(sched_unit_cpu(unit), SCHEDULE_SOFTIRQ);
}
/**
- * Xen scheduler callback function to select a VCPU to run.
+ * Xen scheduler callback function to select a UNIT to run.
* This is the main scheduler routine.
*
* @param ops Pointer to this instance of the scheduler structure
* @param now Current time
*
- * @return Address of the VCPU structure scheduled to be run next
- * Amount of time to execute the returned VCPU
- * Flag for whether the VCPU was migrated
+ * @return Address of the UNIT structure scheduled to be run next
+ * Amount of time to execute the returned UNIT
+ * Flag for whether the UNIT was migrated
*/
static struct task_slice
a653sched_do_schedule(
@@ -514,7 +509,7 @@ a653sched_do_schedule(
bool_t tasklet_work_scheduled)
{
struct task_slice ret; /* hold the chosen domain */
- struct vcpu * new_task = NULL;
+ struct sched_unit *new_task = NULL;
static unsigned int sched_index = 0;
static s_time_t next_switch_time;
a653sched_priv_t *sched_priv = SCHED_PRIV(ops);
@@ -559,14 +554,14 @@ a653sched_do_schedule(
* sched_unit structure.
*/
new_task = (sched_index < sched_priv->num_schedule_entries)
- ? sched_priv->schedule[sched_index].vc
+ ? sched_priv->schedule[sched_index].unit
: IDLETASK(cpu);
/* Check to see if the new task can be run (awake & runnable). */
if ( !((new_task != NULL)
- && (AVCPU(new_task) != NULL)
- && AVCPU(new_task)->awake
- && vcpu_runnable(new_task)) )
+ && (AUNIT(new_task) != NULL)
+ && AUNIT(new_task)->awake
+ && unit_runnable(new_task)) )
new_task = IDLETASK(cpu);
BUG_ON(new_task == NULL);
@@ -578,21 +573,21 @@ a653sched_do_schedule(
spin_unlock_irqrestore(&sched_priv->lock, flags);
- /* Tasklet work (which runs in idle VCPU context) overrides all else. */
+ /* Tasklet work (which runs in idle UNIT context) overrides all else. */
if ( tasklet_work_scheduled )
new_task = IDLETASK(cpu);
/* Running this task would result in a migration */
- if ( !is_idle_vcpu(new_task)
- && (new_task->processor != cpu) )
+ if ( !is_idle_unit(new_task)
+ && (sched_unit_cpu(new_task) != cpu) )
new_task = IDLETASK(cpu);
/*
* Return the amount of time the next domain has to run and the address
- * of the selected task's VCPU structure.
+ * of the selected task's UNIT structure.
*/
ret.time = next_switch_time - now;
- ret.task = new_task->sched_unit;
+ ret.task = new_task;
ret.migrated = 0;
BUG_ON(ret.time <= 0);
@@ -601,7 +596,7 @@ a653sched_do_schedule(
}
/**
- * Xen scheduler callback function to select a resource for the VCPU to run on
+ * Xen scheduler callback function to select a resource for the UNIT to run on
*
* @param ops Pointer to this instance of the scheduler structure
* @param unit Pointer to struct sched_unit
@@ -612,21 +607,20 @@ static struct sched_resource *
a653sched_pick_resource(const struct scheduler *ops,
const struct sched_unit *unit)
{
- struct vcpu *vc = unit->vcpu_list;
cpumask_t *online;
unsigned int cpu;
- /*
- * If present, prefer vc's current processor, else
- * just find the first valid vcpu .
+ /*
+ * If present, prefer unit's current processor, else
+ * just find the first valid unit.
*/
- online = cpupool_domain_cpumask(vc->domain);
+ online = cpupool_domain_cpumask(unit->domain);
cpu = cpumask_first(online);
- if ( cpumask_test_cpu(vc->processor, online)
+ if ( cpumask_test_cpu(sched_unit_cpu(unit), online)
|| (cpu >= nr_cpu_ids) )
- cpu = vc->processor;
+ cpu = sched_unit_cpu(unit);
return get_sched_res(cpu);
}
@@ -637,18 +631,18 @@ a653sched_pick_resource(const struct scheduler *ops,
* @param new_ops Pointer to this instance of the scheduler structure
* @param cpu The cpu that is changing scheduler
* @param pdata scheduler specific PCPU data (we don't have any)
- * @param vdata scheduler specific VCPU data of the idle vcpu
+ * @param vdata scheduler specific UNIT data of the idle unit
*/
static spinlock_t *
a653_switch_sched(struct scheduler *new_ops, unsigned int cpu,
void *pdata, void *vdata)
{
struct sched_resource *sd = get_sched_res(cpu);
- arinc653_vcpu_t *svc = vdata;
+ arinc653_unit_t *svc = vdata;
- ASSERT(!pdata && svc && is_idle_vcpu(svc->vc));
+ ASSERT(!pdata && svc && is_idle_unit(svc->unit));
- idle_vcpu[cpu]->sched_unit->priv = vdata;
+ sched_idle_unit(cpu)->priv = vdata;
return &sd->_lock;
}
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 19/47] xen: add sched_unit_pause_nosync() and sched_unit_unpause()
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (17 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 18/47] xen/sched: make arinc653 " Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-25 15:20 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 20/47] xen: let vcpu_create() select processor Juergen Gross
` (29 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
The credit scheduler calls vcpu_pause_nosync() and vcpu_unpause()
today. Add sched_unit_pause_nosync() and sched_unit_unpause() to
perform the same operations on scheduler units instead.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/sched_credit.c | 6 +++---
xen/include/xen/sched-if.h | 10 ++++++++++
2 files changed, 13 insertions(+), 3 deletions(-)
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index 044b1d8a51..dcaa9f9557 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -1065,7 +1065,7 @@ csched_unit_remove(const struct scheduler *ops, struct sched_unit *unit)
if ( test_and_clear_bit(CSCHED_FLAG_UNIT_PARKED, &svc->flags) )
{
SCHED_STAT_CRANK(unit_unpark);
- vcpu_unpause(svc->unit->vcpu_list);
+ sched_unit_unpause(svc->unit);
}
spin_lock_irq(&prv->lock);
@@ -1515,7 +1515,7 @@ csched_acct(void* dummy)
!test_and_set_bit(CSCHED_FLAG_UNIT_PARKED, &svc->flags) )
{
SCHED_STAT_CRANK(unit_park);
- vcpu_pause_nosync(svc->unit->vcpu_list);
+ sched_unit_pause_nosync(svc->unit);
}
/* Lower bound on credits */
@@ -1539,7 +1539,7 @@ csched_acct(void* dummy)
* if it is woken up here.
*/
SCHED_STAT_CRANK(unit_unpark);
- vcpu_unpause(svc->unit->vcpu_list);
+ sched_unit_unpause(svc->unit);
clear_bit(CSCHED_FLAG_UNIT_PARKED, &svc->flags);
}
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index d624b81e53..b5967d26af 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -432,6 +432,16 @@ static inline int sched_adjust_cpupool(const struct scheduler *s,
return s->adjust_global ? s->adjust_global(s, op) : 0;
}
+static inline void sched_unit_pause_nosync(struct sched_unit *unit)
+{
+ vcpu_pause_nosync(unit->vcpu_list);
+}
+
+static inline void sched_unit_unpause(struct sched_unit *unit)
+{
+ vcpu_unpause(unit->vcpu_list);
+}
+
#define REGISTER_SCHEDULER(x) static const struct scheduler *x##_entry \
__used_section(".data.schedulers") = &x;
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 20/47] xen: let vcpu_create() select processor
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (18 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 19/47] xen: add sched_unit_pause_nosync() and sched_unit_unpause() Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-25 16:31 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 21/47] xen/sched: use sched_resource cpu instead smp_processor_id in schedulers Juergen Gross
` (28 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Tim Deegan, Julien Grall, Jan Beulich, Dario Faggioli,
Volodymyr Babchuk, Roger Pau Monné
Today there are two distinct scenarios for vcpu_create(): either for
creation of idle-domain vcpus (vcpuid == processor) or for creation of
"normal" domain vcpus (including dom0), where the caller selects the
initial processor on a round-robin scheme of the allowed processors
(allowed being based on cpupool and affinities).
Instead of passing the initial processor to vcpu_create() and passing
on to sched_init_vcpu() let sched_init_vcpu() do the processor
selection. For supporting dom0 vcpu creation use the node_affinity of
the domain as a base for selecting the processors. User domains will
have initially all nodes set, so this is no different behavior compared
to today. In theory this is not guaranteed as vcpus are created only
with XEN_DOMCTL_max_vcpus being called, but this call is going to be
removed in future and the toolstack doesn't call
XEN_DOMCTL_setnodeaffinity before calling XEN_DOMCTL_max_vcpus.
To be able to use const struct domain * make cpupool_domain_cpumask()
take a const domain pointer, too.
Signed-off-by: Juergen Gross <jgross@suse.com>
Acked-by: Andrew Cooper <andrew.cooper3@citrix.com>
Acked-by: Julien Grall <julien.grall@arm.com>
---
RFC V2:
- add ASSERT(), modify error message (Andrew Cooper)
V1:
- constify pointers, avoid cpumask on stack (Jan Beulich)
V3:
- style correction (Jan Beulich)
---
xen/arch/arm/domain_build.c | 13 ++++++------
xen/arch/x86/dom0_build.c | 10 +++------
xen/arch/x86/hvm/dom0_build.c | 9 ++------
xen/arch/x86/pv/dom0_build.c | 10 ++-------
xen/common/domain.c | 5 ++---
xen/common/domctl.c | 10 ++-------
xen/common/schedule.c | 44 +++++++++++++++++++++++++++++++++++++---
xen/include/asm-x86/dom0_build.h | 3 +--
xen/include/xen/domain.h | 3 +--
xen/include/xen/sched-if.h | 2 +-
xen/include/xen/sched.h | 2 +-
11 files changed, 62 insertions(+), 49 deletions(-)
diff --git a/xen/arch/arm/domain_build.c b/xen/arch/arm/domain_build.c
index a0fee1ef13..f6575f918d 100644
--- a/xen/arch/arm/domain_build.c
+++ b/xen/arch/arm/domain_build.c
@@ -80,7 +80,7 @@ unsigned int __init dom0_max_vcpus(void)
struct vcpu *__init alloc_dom0_vcpu0(struct domain *dom0)
{
- return vcpu_create(dom0, 0, 0);
+ return vcpu_create(dom0, 0);
}
static unsigned int __init get_allocation_size(paddr_t size)
@@ -1925,7 +1925,7 @@ static void __init find_gnttab_region(struct domain *d,
static int __init construct_domain(struct domain *d, struct kernel_info *kinfo)
{
- int i, cpu;
+ int i;
struct vcpu *v = d->vcpu[0];
struct cpu_user_regs *regs = &v->arch.cpu_info->guest_cpu_user_regs;
@@ -1988,12 +1988,11 @@ static int __init construct_domain(struct domain *d, struct kernel_info *kinfo)
}
#endif
- for ( i = 1, cpu = 0; i < d->max_vcpus; i++ )
+ for ( i = 1; i < d->max_vcpus; i++ )
{
- cpu = cpumask_cycle(cpu, &cpu_online_map);
- if ( vcpu_create(d, i, cpu) == NULL )
+ if ( vcpu_create(d, i) == NULL )
{
- printk("Failed to allocate dom0 vcpu %d on pcpu %d\n", i, cpu);
+ printk("Failed to allocate d0v%u\n", i);
break;
}
@@ -2028,7 +2027,7 @@ static int __init construct_domU(struct domain *d,
kinfo.vpl011 = dt_property_read_bool(node, "vpl011");
- if ( vcpu_create(d, 0, 0) == NULL )
+ if ( vcpu_create(d, 0) == NULL )
return -ENOMEM;
d->max_pages = ~0U;
diff --git a/xen/arch/x86/dom0_build.c b/xen/arch/x86/dom0_build.c
index c69570920c..6265dd4a1c 100644
--- a/xen/arch/x86/dom0_build.c
+++ b/xen/arch/x86/dom0_build.c
@@ -198,12 +198,9 @@ custom_param("dom0_nodes", parse_dom0_nodes);
static cpumask_t __initdata dom0_cpus;
-struct vcpu *__init dom0_setup_vcpu(struct domain *d,
- unsigned int vcpu_id,
- unsigned int prev_cpu)
+struct vcpu *__init dom0_setup_vcpu(struct domain *d, unsigned int vcpu_id)
{
- unsigned int cpu = cpumask_cycle(prev_cpu, &dom0_cpus);
- struct vcpu *v = vcpu_create(d, vcpu_id, cpu);
+ struct vcpu *v = vcpu_create(d, vcpu_id);
if ( v )
{
@@ -273,8 +270,7 @@ struct vcpu *__init alloc_dom0_vcpu0(struct domain *dom0)
dom0->node_affinity = dom0_nodes;
dom0->auto_node_affinity = !dom0_nr_pxms;
- return dom0_setup_vcpu(dom0, 0,
- cpumask_last(&dom0_cpus) /* so it wraps around to first pcpu */);
+ return dom0_setup_vcpu(dom0, 0);
}
#ifdef CONFIG_SHADOW_PAGING
diff --git a/xen/arch/x86/hvm/dom0_build.c b/xen/arch/x86/hvm/dom0_build.c
index 8845399ae9..fd8d9609b1 100644
--- a/xen/arch/x86/hvm/dom0_build.c
+++ b/xen/arch/x86/hvm/dom0_build.c
@@ -614,7 +614,7 @@ static int __init pvh_setup_cpus(struct domain *d, paddr_t entry,
paddr_t start_info)
{
struct vcpu *v = d->vcpu[0];
- unsigned int cpu = v->processor, i;
+ unsigned int i;
int rc;
/*
* This sets the vCPU state according to the state described in
@@ -636,12 +636,7 @@ static int __init pvh_setup_cpus(struct domain *d, paddr_t entry,
};
for ( i = 1; i < d->max_vcpus; i++ )
- {
- const struct vcpu *p = dom0_setup_vcpu(d, i, cpu);
-
- if ( p )
- cpu = p->processor;
- }
+ dom0_setup_vcpu(d, i);
domain_update_node_affinity(d);
diff --git a/xen/arch/x86/pv/dom0_build.c b/xen/arch/x86/pv/dom0_build.c
index 1bd53e9c08..565c6c8b44 100644
--- a/xen/arch/x86/pv/dom0_build.c
+++ b/xen/arch/x86/pv/dom0_build.c
@@ -285,7 +285,7 @@ int __init dom0_construct_pv(struct domain *d,
module_t *initrd,
char *cmdline)
{
- int i, cpu, rc, compatible, order, machine;
+ int i, rc, compatible, order, machine;
struct cpu_user_regs *regs;
unsigned long pfn, mfn;
unsigned long nr_pages;
@@ -694,14 +694,8 @@ int __init dom0_construct_pv(struct domain *d,
printk("Dom%u has maximum %u VCPUs\n", d->domain_id, d->max_vcpus);
- cpu = v->processor;
for ( i = 1; i < d->max_vcpus; i++ )
- {
- const struct vcpu *p = dom0_setup_vcpu(d, i, cpu);
-
- if ( p )
- cpu = p->processor;
- }
+ dom0_setup_vcpu(d, i);
domain_update_node_affinity(d);
d->arch.paging.mode = 0;
diff --git a/xen/common/domain.c b/xen/common/domain.c
index 8c782ee03f..a3e23f2ee7 100644
--- a/xen/common/domain.c
+++ b/xen/common/domain.c
@@ -135,8 +135,7 @@ static void vcpu_destroy(struct vcpu *v)
free_vcpu_struct(v);
}
-struct vcpu *vcpu_create(
- struct domain *d, unsigned int vcpu_id, unsigned int cpu_id)
+struct vcpu *vcpu_create(struct domain *d, unsigned int vcpu_id)
{
struct vcpu *v;
@@ -168,7 +167,7 @@ struct vcpu *vcpu_create(
init_waitqueue_vcpu(v);
}
- if ( sched_init_vcpu(v, cpu_id) != 0 )
+ if ( sched_init_vcpu(v) != 0 )
goto fail_wq;
if ( arch_vcpu_create(v) != 0 )
diff --git a/xen/common/domctl.c b/xen/common/domctl.c
index 2f9768f08f..8a694e0d37 100644
--- a/xen/common/domctl.c
+++ b/xen/common/domctl.c
@@ -532,8 +532,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl)
case XEN_DOMCTL_max_vcpus:
{
- unsigned int i, max = op->u.max_vcpus.max, cpu;
- cpumask_t *online;
+ unsigned int i, max = op->u.max_vcpus.max;
ret = -EINVAL;
if ( (d == current->domain) || /* no domain_pause() */
@@ -544,18 +543,13 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl)
domain_pause(d);
ret = -ENOMEM;
- online = cpupool_domain_cpumask(d);
for ( i = 0; i < max; i++ )
{
if ( d->vcpu[i] != NULL )
continue;
- cpu = (i == 0) ?
- cpumask_any(online) :
- cpumask_cycle(d->vcpu[i-1]->processor, online);
-
- if ( vcpu_create(d, i, cpu) == NULL )
+ if ( vcpu_create(d, i) == NULL )
goto maxvcpu_out;
}
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 05bc42d7e9..74769f2f9b 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -371,14 +371,52 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
return NULL;
}
-int sched_init_vcpu(struct vcpu *v, unsigned int processor)
+static unsigned int sched_select_initial_cpu(const struct vcpu *v)
+{
+ const struct domain *d = v->domain;
+ nodeid_t node;
+ spinlock_t *lock;
+ unsigned long flags;
+ unsigned int cpu_ret, cpu = smp_processor_id();
+ cpumask_t *cpus = cpumask_scratch_cpu(cpu);
+
+ lock = pcpu_schedule_lock_irqsave(cpu, &flags);
+ cpumask_clear(cpus);
+ for_each_node_mask ( node, d->node_affinity )
+ cpumask_or(cpus, cpus, &node_to_cpumask(node));
+ cpumask_and(cpus, cpus, cpupool_domain_cpumask(d));
+ if ( cpumask_empty(cpus) )
+ cpumask_copy(cpus, cpupool_domain_cpumask(d));
+
+ if ( v->vcpu_id == 0 )
+ cpu_ret = cpumask_first(cpus);
+ else
+ {
+ /* We can rely on previous vcpu being available. */
+ ASSERT(!is_idle_domain(d));
+
+ cpu_ret = cpumask_cycle(d->vcpu[v->vcpu_id - 1]->processor, cpus);
+ }
+
+ pcpu_schedule_unlock_irqrestore(lock, flags, cpu);
+
+ return cpu_ret;
+}
+
+int sched_init_vcpu(struct vcpu *v)
{
struct domain *d = v->domain;
struct sched_unit *unit;
+ unsigned int processor;
if ( (unit = sched_alloc_unit(v)) == NULL )
return 1;
+ if ( is_idle_domain(d) )
+ processor = v->vcpu_id;
+ else
+ processor = sched_select_initial_cpu(v);
+
sched_set_res(unit, get_sched_res(processor));
/* Initialise the per-vcpu timers. */
@@ -1763,7 +1801,7 @@ static int cpu_schedule_up(unsigned int cpu)
return 0;
if ( idle_vcpu[cpu] == NULL )
- vcpu_create(idle_vcpu[0]->domain, cpu, cpu);
+ vcpu_create(idle_vcpu[0]->domain, cpu);
else
idle_vcpu[cpu]->sched_unit->res = sd;
@@ -1942,7 +1980,7 @@ void __init scheduler_init(void)
BUG_ON(nr_cpu_ids > ARRAY_SIZE(idle_vcpu));
idle_domain->vcpu = idle_vcpu;
idle_domain->max_vcpus = nr_cpu_ids;
- if ( vcpu_create(idle_domain, 0, 0) == NULL )
+ if ( vcpu_create(idle_domain, 0) == NULL )
BUG();
get_sched_res(0)->curr = idle_vcpu[0]->sched_unit;
}
diff --git a/xen/include/asm-x86/dom0_build.h b/xen/include/asm-x86/dom0_build.h
index 33a5483739..3eb4b036e1 100644
--- a/xen/include/asm-x86/dom0_build.h
+++ b/xen/include/asm-x86/dom0_build.h
@@ -11,8 +11,7 @@ extern unsigned int dom0_memflags;
unsigned long dom0_compute_nr_pages(struct domain *d,
struct elf_dom_parms *parms,
unsigned long initrd_len);
-struct vcpu *dom0_setup_vcpu(struct domain *d, unsigned int vcpu_id,
- unsigned int cpu);
+struct vcpu *dom0_setup_vcpu(struct domain *d, unsigned int vcpu_id);
int dom0_setup_permissions(struct domain *d);
int dom0_construct_pv(struct domain *d, const module_t *image,
diff --git a/xen/include/xen/domain.h b/xen/include/xen/domain.h
index 3f09cb66c0..4ca3db5a18 100644
--- a/xen/include/xen/domain.h
+++ b/xen/include/xen/domain.h
@@ -13,8 +13,7 @@ typedef union {
struct compat_vcpu_guest_context *cmp;
} vcpu_guest_context_u __attribute__((__transparent_union__));
-struct vcpu *vcpu_create(
- struct domain *d, unsigned int vcpu_id, unsigned int cpu_id);
+struct vcpu *vcpu_create(struct domain *d, unsigned int vcpu_id);
unsigned int dom0_max_vcpus(void);
struct vcpu *alloc_dom0_vcpu0(struct domain *dom0);
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index b5967d26af..f70182dd4e 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -458,7 +458,7 @@ struct cpupool
#define cpupool_online_cpumask(_pool) \
(((_pool) == NULL) ? &cpu_online_map : (_pool)->cpu_valid)
-static inline cpumask_t* cpupool_domain_cpumask(struct domain *d)
+static inline cpumask_t *cpupool_domain_cpumask(const struct domain *d)
{
/*
* d->cpupool is NULL only for the idle domain, and no one should
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index d4698b3f0d..56ed863b08 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -659,7 +659,7 @@ void __domain_crash(struct domain *d);
void noreturn asm_domain_crash_synchronous(unsigned long addr);
void scheduler_init(void);
-int sched_init_vcpu(struct vcpu *v, unsigned int processor);
+int sched_init_vcpu(struct vcpu *v);
void sched_destroy_vcpu(struct vcpu *v);
int sched_init_domain(struct domain *d, int poolid);
void sched_destroy_domain(struct domain *d);
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 21/47] xen/sched: use sched_resource cpu instead smp_processor_id in schedulers
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (19 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 20/47] xen: let vcpu_create() select processor Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-26 10:01 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 22/47] xen/sched: switch schedule() from vcpus to sched_units Juergen Gross
` (27 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Robert VanVossen, Dario Faggioli, Julien Grall, Josh Whitehead,
Meng Xu, Jan Beulich
Especially in the do_schedule() functions of the different schedulers
using smp_processor_id() for the local cpu number is correct only if
the sched_unit is a single vcpu. As soon as larger sched_units are
used most uses should be replaced by the master_cpu number of the local
sched_resource instead.
Add a helper to get that sched_resource master_cpu and modify the
schedulers to use it in a correct way.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V3:
- style correction (Jan Beulich)
- rename cpu to cur_cpu when introducing sched_cpu in same function
(Jan Beulich)
- undo change in sched_idle_schedule() (Jan Beulich)
---
xen/common/sched_arinc653.c | 2 +-
xen/common/sched_credit.c | 23 ++++++++++---------
xen/common/sched_credit2.c | 55 +++++++++++++++++++++++----------------------
xen/common/sched_null.c | 25 +++++++++++----------
xen/common/sched_rt.c | 19 ++++++++--------
xen/include/xen/sched-if.h | 5 +++++
6 files changed, 69 insertions(+), 60 deletions(-)
diff --git a/xen/common/sched_arinc653.c b/xen/common/sched_arinc653.c
index 8c431e6edd..a4db34843b 100644
--- a/xen/common/sched_arinc653.c
+++ b/xen/common/sched_arinc653.c
@@ -513,7 +513,7 @@ a653sched_do_schedule(
static unsigned int sched_index = 0;
static s_time_t next_switch_time;
a653sched_priv_t *sched_priv = SCHED_PRIV(ops);
- const unsigned int cpu = smp_processor_id();
+ const unsigned int cpu = sched_get_resource_cpu(smp_processor_id());
unsigned long flags;
spin_lock_irqsave(&sched_priv->lock, flags);
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index dcaa9f9557..203c5decef 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -1684,7 +1684,7 @@ csched_load_balance(struct csched_private *prv, int cpu,
int peer_cpu, first_cpu, peer_node, bstep;
int node = cpu_to_node(cpu);
- BUG_ON( cpu != sched_unit_cpu(snext->unit) );
+ BUG_ON(sched_get_resource_cpu(cpu) != sched_unit_cpu(snext->unit));
online = cpupool_online_cpumask(c);
/*
@@ -1825,8 +1825,9 @@ static struct task_slice
csched_schedule(
const struct scheduler *ops, s_time_t now, bool_t tasklet_work_scheduled)
{
- const int cpu = smp_processor_id();
- struct list_head * const runq = RUNQ(cpu);
+ const unsigned int cur_cpu = smp_processor_id();
+ const unsigned int sched_cpu = sched_get_resource_cpu(cur_cpu);
+ struct list_head * const runq = RUNQ(sched_cpu);
struct sched_unit *unit = current->sched_unit;
struct csched_unit * const scurr = CSCHED_UNIT(unit);
struct csched_private *prv = CSCHED_PRIV(ops);
@@ -1847,7 +1848,7 @@ csched_schedule(
struct {
unsigned cpu:16, tasklet:8, idle:8;
} d;
- d.cpu = cpu;
+ d.cpu = cur_cpu;
d.tasklet = tasklet_work_scheduled;
d.idle = is_idle_unit(unit);
__trace_var(TRC_CSCHED_SCHEDULE, 1, sizeof(d),
@@ -1937,7 +1938,7 @@ csched_schedule(
{
BUG_ON( is_idle_unit(unit) || list_empty(runq) );
/* Current has blocked. Update the runnable counter for this cpu. */
- dec_nr_runnable(cpu);
+ dec_nr_runnable(sched_cpu);
}
snext = __runq_elem(runq->next);
@@ -1947,7 +1948,7 @@ csched_schedule(
if ( tasklet_work_scheduled )
{
TRACE_0D(TRC_CSCHED_SCHED_TASKLET);
- snext = CSCHED_UNIT(sched_idle_unit(cpu));
+ snext = CSCHED_UNIT(sched_idle_unit(sched_cpu));
snext->pri = CSCHED_PRI_TS_BOOST;
}
@@ -1967,7 +1968,7 @@ csched_schedule(
if ( snext->pri > CSCHED_PRI_TS_OVER )
__runq_remove(snext);
else
- snext = csched_load_balance(prv, cpu, snext, &ret.migrated);
+ snext = csched_load_balance(prv, sched_cpu, snext, &ret.migrated);
/*
* Update idlers mask if necessary. When we're idling, other CPUs
@@ -1975,12 +1976,12 @@ csched_schedule(
*/
if ( !tasklet_work_scheduled && snext->pri == CSCHED_PRI_IDLE )
{
- if ( !cpumask_test_cpu(cpu, prv->idlers) )
- cpumask_set_cpu(cpu, prv->idlers);
+ if ( !cpumask_test_cpu(sched_cpu, prv->idlers) )
+ cpumask_set_cpu(sched_cpu, prv->idlers);
}
- else if ( cpumask_test_cpu(cpu, prv->idlers) )
+ else if ( cpumask_test_cpu(sched_cpu, prv->idlers) )
{
- cpumask_clear_cpu(cpu, prv->idlers);
+ cpumask_clear_cpu(sched_cpu, prv->idlers);
}
if ( !is_idle_unit(snext->unit) )
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 0d1ba97dbc..cf0559e964 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -3448,7 +3448,8 @@ static struct task_slice
csched2_schedule(
const struct scheduler *ops, s_time_t now, bool tasklet_work_scheduled)
{
- const int cpu = smp_processor_id();
+ const unsigned int cur_cpu = smp_processor_id();
+ const unsigned int sched_cpu = sched_get_resource_cpu(cur_cpu);
struct csched2_runqueue_data *rqd;
struct sched_unit *currunit = current->sched_unit;
struct csched2_unit * const scurr = csched2_unit(currunit);
@@ -3460,22 +3461,22 @@ csched2_schedule(
SCHED_STAT_CRANK(schedule);
CSCHED2_UNIT_CHECK(currunit);
- BUG_ON(!cpumask_test_cpu(cpu, &csched2_priv(ops)->initialized));
+ BUG_ON(!cpumask_test_cpu(sched_cpu, &csched2_priv(ops)->initialized));
- rqd = c2rqd(ops, cpu);
- BUG_ON(!cpumask_test_cpu(cpu, &rqd->active));
+ rqd = c2rqd(ops, sched_cpu);
+ BUG_ON(!cpumask_test_cpu(sched_cpu, &rqd->active));
- ASSERT(spin_is_locked(get_sched_res(cpu)->schedule_lock));
+ ASSERT(spin_is_locked(get_sched_res(sched_cpu)->schedule_lock));
BUG_ON(!is_idle_unit(currunit) && scurr->rqd != rqd);
/* Clear "tickled" bit now that we've been scheduled */
- tickled = cpumask_test_cpu(cpu, &rqd->tickled);
+ tickled = cpumask_test_cpu(sched_cpu, &rqd->tickled);
if ( tickled )
{
- __cpumask_clear_cpu(cpu, &rqd->tickled);
+ __cpumask_clear_cpu(sched_cpu, &rqd->tickled);
cpumask_andnot(cpumask_scratch, &rqd->idle, &rqd->tickled);
- smt_idle_mask_set(cpu, cpumask_scratch, &rqd->smt_idle);
+ smt_idle_mask_set(sched_cpu, cpumask_scratch, &rqd->smt_idle);
}
if ( unlikely(tb_init_done) )
@@ -3484,11 +3485,11 @@ csched2_schedule(
unsigned cpu:16, rq_id:16;
unsigned tasklet:8, idle:8, smt_idle:8, tickled:8;
} d;
- d.cpu = cpu;
- d.rq_id = c2r(cpu);
+ d.cpu = cur_cpu;
+ d.rq_id = c2r(sched_cpu);
d.tasklet = tasklet_work_scheduled;
d.idle = is_idle_unit(currunit);
- d.smt_idle = cpumask_test_cpu(cpu, &rqd->smt_idle);
+ d.smt_idle = cpumask_test_cpu(sched_cpu, &rqd->smt_idle);
d.tickled = tickled;
__trace_var(TRC_CSCHED2_SCHEDULE, 1,
sizeof(d),
@@ -3528,10 +3529,10 @@ csched2_schedule(
{
__clear_bit(__CSFLAG_unit_yield, &scurr->flags);
trace_var(TRC_CSCHED2_SCHED_TASKLET, 1, 0, NULL);
- snext = csched2_unit(sched_idle_unit(cpu));
+ snext = csched2_unit(sched_idle_unit(sched_cpu));
}
else
- snext = runq_candidate(rqd, scurr, cpu, now, &skipped_units);
+ snext = runq_candidate(rqd, scurr, sched_cpu, now, &skipped_units);
/* If switching from a non-idle runnable unit, put it
* back on the runqueue. */
@@ -3556,10 +3557,10 @@ csched2_schedule(
}
/* Clear the idle mask if necessary */
- if ( cpumask_test_cpu(cpu, &rqd->idle) )
+ if ( cpumask_test_cpu(sched_cpu, &rqd->idle) )
{
- __cpumask_clear_cpu(cpu, &rqd->idle);
- smt_idle_mask_clear(cpu, &rqd->smt_idle);
+ __cpumask_clear_cpu(sched_cpu, &rqd->idle);
+ smt_idle_mask_clear(sched_cpu, &rqd->smt_idle);
}
/*
@@ -3578,18 +3579,18 @@ csched2_schedule(
*/
if ( skipped_units == 0 && snext->credit <= CSCHED2_CREDIT_RESET )
{
- reset_credit(ops, cpu, now, snext);
- balance_load(ops, cpu, now);
+ reset_credit(ops, sched_cpu, now, snext);
+ balance_load(ops, sched_cpu, now);
}
snext->start_time = now;
snext->tickled_cpu = -1;
/* Safe because lock for old processor is held */
- if ( sched_unit_cpu(snext->unit) != cpu )
+ if ( sched_unit_cpu(snext->unit) != sched_cpu )
{
snext->credit += CSCHED2_MIGRATE_COMPENSATION;
- sched_set_res(snext->unit, get_sched_res(cpu));
+ sched_set_res(snext->unit, get_sched_res(sched_cpu));
SCHED_STAT_CRANK(migrated);
ret.migrated = 1;
}
@@ -3602,17 +3603,17 @@ csched2_schedule(
*/
if ( tasklet_work_scheduled )
{
- if ( cpumask_test_cpu(cpu, &rqd->idle) )
+ if ( cpumask_test_cpu(sched_cpu, &rqd->idle) )
{
- __cpumask_clear_cpu(cpu, &rqd->idle);
- smt_idle_mask_clear(cpu, &rqd->smt_idle);
+ __cpumask_clear_cpu(sched_cpu, &rqd->idle);
+ smt_idle_mask_clear(sched_cpu, &rqd->smt_idle);
}
}
- else if ( !cpumask_test_cpu(cpu, &rqd->idle) )
+ else if ( !cpumask_test_cpu(sched_cpu, &rqd->idle) )
{
- __cpumask_set_cpu(cpu, &rqd->idle);
+ __cpumask_set_cpu(sched_cpu, &rqd->idle);
cpumask_andnot(cpumask_scratch, &rqd->idle, &rqd->tickled);
- smt_idle_mask_set(cpu, cpumask_scratch, &rqd->smt_idle);
+ smt_idle_mask_set(sched_cpu, cpumask_scratch, &rqd->smt_idle);
}
/* Make sure avgload gets updated periodically even
* if there's no activity */
@@ -3622,7 +3623,7 @@ csched2_schedule(
/*
* Return task to run next...
*/
- ret.time = csched2_runtime(ops, cpu, snext, now);
+ ret.time = csched2_runtime(ops, sched_cpu, snext, now);
ret.task = snext->unit;
CSCHED2_UNIT_CHECK(ret.task);
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index c3666c9f56..4131df0db3 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -784,7 +784,8 @@ static struct task_slice null_schedule(const struct scheduler *ops,
bool_t tasklet_work_scheduled)
{
unsigned int bs;
- const unsigned int cpu = smp_processor_id();
+ const unsigned int cur_cpu = smp_processor_id();
+ const unsigned int sched_cpu = sched_get_resource_cpu(cur_cpu);
struct null_private *prv = null_priv(ops);
struct null_unit *wvc;
struct task_slice ret;
@@ -798,16 +799,16 @@ static struct task_slice null_schedule(const struct scheduler *ops,
uint16_t tasklet, cpu;
int16_t unit, dom;
} d;
- d.cpu = cpu;
+ d.cpu = cur_cpu;
d.tasklet = tasklet_work_scheduled;
- if ( per_cpu(npc, cpu).unit == NULL )
+ if ( per_cpu(npc, sched_cpu).unit == NULL )
{
d.unit = d.dom = -1;
}
else
{
- d.unit = per_cpu(npc, cpu).unit->unit_id;
- d.dom = per_cpu(npc, cpu).unit->domain->domain_id;
+ d.unit = per_cpu(npc, sched_cpu).unit->unit_id;
+ d.dom = per_cpu(npc, sched_cpu).unit->domain->domain_id;
}
__trace_var(TRC_SNULL_SCHEDULE, 1, sizeof(d), &d);
}
@@ -815,10 +816,10 @@ static struct task_slice null_schedule(const struct scheduler *ops,
if ( tasklet_work_scheduled )
{
trace_var(TRC_SNULL_TASKLET, 1, 0, NULL);
- ret.task = sched_idle_unit(cpu);
+ ret.task = sched_idle_unit(sched_cpu);
}
else
- ret.task = per_cpu(npc, cpu).unit;
+ ret.task = per_cpu(npc, sched_cpu).unit;
ret.migrated = 0;
ret.time = -1;
@@ -849,9 +850,9 @@ static struct task_slice null_schedule(const struct scheduler *ops,
!has_soft_affinity(wvc->unit) )
continue;
- if ( unit_check_affinity(wvc->unit, cpu, bs) )
+ if ( unit_check_affinity(wvc->unit, sched_cpu, bs) )
{
- unit_assign(prv, wvc->unit, cpu);
+ unit_assign(prv, wvc->unit, sched_cpu);
list_del_init(&wvc->waitq_elem);
ret.task = wvc->unit;
goto unlock;
@@ -861,12 +862,12 @@ static struct task_slice null_schedule(const struct scheduler *ops,
unlock:
spin_unlock(&prv->waitq_lock);
- if ( ret.task == NULL && !cpumask_test_cpu(cpu, &prv->cpus_free) )
- cpumask_set_cpu(cpu, &prv->cpus_free);
+ if ( ret.task == NULL && !cpumask_test_cpu(sched_cpu, &prv->cpus_free) )
+ cpumask_set_cpu(sched_cpu, &prv->cpus_free);
}
if ( unlikely(ret.task == NULL || !unit_runnable(ret.task)) )
- ret.task = sched_idle_unit(cpu);
+ ret.task = sched_idle_unit(sched_cpu);
NULL_UNIT_CHECK(ret.task);
return ret;
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index 7a72cfb86c..ab48d4bb1d 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -1057,7 +1057,8 @@ runq_pick(const struct scheduler *ops, const cpumask_t *mask)
static struct task_slice
rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_scheduled)
{
- const int cpu = smp_processor_id();
+ const unsigned int cur_cpu = smp_processor_id();
+ const unsigned int sched_cpu = sched_get_resource_cpu(cur_cpu);
struct rt_private *prv = rt_priv(ops);
struct rt_unit *const scurr = rt_unit(current->sched_unit);
struct rt_unit *snext = NULL;
@@ -1069,9 +1070,9 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
struct __packed {
unsigned cpu:16, tasklet:8, tickled:4, idle:4;
} d;
- d.cpu = cpu;
+ d.cpu = cur_cpu;
d.tasklet = tasklet_work_scheduled;
- d.tickled = cpumask_test_cpu(cpu, &prv->tickled);
+ d.tickled = cpumask_test_cpu(sched_cpu, &prv->tickled);
d.idle = is_idle_unit(currunit);
trace_var(TRC_RTDS_SCHEDULE, 1,
sizeof(d),
@@ -1079,7 +1080,7 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
}
/* clear ticked bit now that we've been scheduled */
- cpumask_clear_cpu(cpu, &prv->tickled);
+ cpumask_clear_cpu(sched_cpu, &prv->tickled);
/* burn_budget would return for IDLE UNIT */
burn_budget(ops, scurr, now);
@@ -1087,13 +1088,13 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
if ( tasklet_work_scheduled )
{
trace_var(TRC_RTDS_SCHED_TASKLET, 1, 0, NULL);
- snext = rt_unit(sched_idle_unit(cpu));
+ snext = rt_unit(sched_idle_unit(sched_cpu));
}
else
{
- snext = runq_pick(ops, cpumask_of(cpu));
+ snext = runq_pick(ops, cpumask_of(sched_cpu));
if ( snext == NULL )
- snext = rt_unit(sched_idle_unit(cpu));
+ snext = rt_unit(sched_idle_unit(sched_cpu));
/* if scurr has higher priority and budget, still pick scurr */
if ( !is_idle_unit(currunit) &&
@@ -1118,9 +1119,9 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
q_remove(snext);
__set_bit(__RTDS_scheduled, &snext->flags);
}
- if ( sched_unit_cpu(snext->unit) != cpu )
+ if ( sched_unit_cpu(snext->unit) != sched_cpu )
{
- sched_set_res(snext->unit, get_sched_res(cpu));
+ sched_set_res(snext->unit, get_sched_res(sched_cpu));
ret.migrated = 1;
}
ret.time = snext->cur_budget; /* invoke the scheduler next time */
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index f70182dd4e..8429e9e287 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -116,6 +116,11 @@ static inline struct sched_unit *sched_idle_unit(unsigned int cpu)
return idle_vcpu[cpu]->sched_unit;
}
+static inline unsigned int sched_get_resource_cpu(unsigned int cpu)
+{
+ return get_sched_res(cpu)->master_cpu;
+}
+
/*
* Scratch space, for avoiding having too many cpumask_t on the stack.
* Within each scheduler, when using the scratch mask of one pCPU:
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 22/47] xen/sched: switch schedule() from vcpus to sched_units
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (20 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 21/47] xen/sched: use sched_resource cpu instead smp_processor_id in schedulers Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-25 16:34 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 23/47] xen/sched: switch sched_move_irqs() to take sched_unit as parameter Juergen Gross
` (26 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Dario Faggioli
Use sched_units instead of vcpus in schedule(). This includes the
introduction of sched_unit_runstate_change() as a replacement of
vcpu_runstate_change() in schedule().
Signed-off-by: Juergen Gross <jgross@suse.com>
---
Note that sched_unit_runstate_change() will be subsumed by another
rework in a later patch.
---
xen/common/schedule.c | 68 +++++++++++++++++++++++++++++----------------------
1 file changed, 39 insertions(+), 29 deletions(-)
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 74769f2f9b..2272192d49 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -251,6 +251,20 @@ static inline void vcpu_runstate_change(
v->runstate.state = new_state;
}
+static inline void sched_unit_runstate_change(struct sched_unit *unit,
+ bool running, s_time_t new_entry_time)
+{
+ struct vcpu *v = unit->vcpu_list;
+
+ if ( running )
+ vcpu_runstate_change(v, RUNSTATE_running, new_entry_time);
+ else
+ vcpu_runstate_change(v,
+ ((v->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
+ (vcpu_runnable(v) ? RUNSTATE_runnable : RUNSTATE_offline)),
+ new_entry_time);
+}
+
void vcpu_runstate_get(struct vcpu *v, struct vcpu_runstate_info *runstate)
{
spinlock_t *lock = likely(v == current)
@@ -1623,7 +1637,7 @@ void vcpu_set_periodic_timer(struct vcpu *v, s_time_t value)
*/
static void schedule(void)
{
- struct vcpu *prev = current, *next = NULL;
+ struct sched_unit *prev = current->sched_unit, *next = NULL;
s_time_t now;
struct scheduler *sched;
unsigned long *tasklet_work = &this_cpu(tasklet_work_to_do);
@@ -1667,9 +1681,9 @@ static void schedule(void)
sched = this_cpu(scheduler);
next_slice = sched->do_schedule(sched, now, tasklet_work_scheduled);
- next = next_slice.task->vcpu_list;
+ next = next_slice.task;
- sd->curr = next->sched_unit;
+ sd->curr = next;
if ( next_slice.time >= 0 ) /* -ve means no limit */
set_timer(&sd->s_timer, now + next_slice.time);
@@ -1678,59 +1692,55 @@ static void schedule(void)
{
pcpu_schedule_unlock_irq(lock, cpu);
TRACE_4D(TRC_SCHED_SWITCH_INFCONT,
- next->domain->domain_id, next->vcpu_id,
- now - prev->runstate.state_entry_time,
+ next->domain->domain_id, next->unit_id,
+ now - prev->state_entry_time,
next_slice.time);
- trace_continue_running(next);
- return continue_running(prev);
+ trace_continue_running(next->vcpu_list);
+ return continue_running(prev->vcpu_list);
}
TRACE_3D(TRC_SCHED_SWITCH_INFPREV,
- prev->domain->domain_id, prev->vcpu_id,
- now - prev->runstate.state_entry_time);
+ prev->domain->domain_id, prev->unit_id,
+ now - prev->state_entry_time);
TRACE_4D(TRC_SCHED_SWITCH_INFNEXT,
- next->domain->domain_id, next->vcpu_id,
- (next->runstate.state == RUNSTATE_runnable) ?
- (now - next->runstate.state_entry_time) : 0,
+ next->domain->domain_id, next->unit_id,
+ (next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
+ (now - next->state_entry_time) : 0,
next_slice.time);
- ASSERT(prev->runstate.state == RUNSTATE_running);
+ ASSERT(prev->vcpu_list->runstate.state == RUNSTATE_running);
TRACE_4D(TRC_SCHED_SWITCH,
- prev->domain->domain_id, prev->vcpu_id,
- next->domain->domain_id, next->vcpu_id);
+ prev->domain->domain_id, prev->unit_id,
+ next->domain->domain_id, next->unit_id);
- vcpu_runstate_change(
- prev,
- ((prev->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
- (vcpu_runnable(prev) ? RUNSTATE_runnable : RUNSTATE_offline)),
- now);
+ sched_unit_runstate_change(prev, false, now);
- ASSERT(next->runstate.state != RUNSTATE_running);
- vcpu_runstate_change(next, RUNSTATE_running, now);
+ ASSERT(next->vcpu_list->runstate.state != RUNSTATE_running);
+ sched_unit_runstate_change(next, true, now);
/*
* NB. Don't add any trace records from here until the actual context
* switch, else lost_records resume will not work properly.
*/
- ASSERT(!next->sched_unit->is_running);
+ ASSERT(!next->is_running);
+ next->vcpu_list->is_running = 1;
next->is_running = 1;
- next->sched_unit->is_running = 1;
- next->sched_unit->state_entry_time = now;
+ next->state_entry_time = now;
pcpu_schedule_unlock_irq(lock, cpu);
SCHED_STAT_CRANK(sched_ctx);
- stop_timer(&prev->periodic_timer);
+ stop_timer(&prev->vcpu_list->periodic_timer);
if ( next_slice.migrated )
- sched_move_irqs(next);
+ sched_move_irqs(next->vcpu_list);
- vcpu_periodic_timer_work(next);
+ vcpu_periodic_timer_work(next->vcpu_list);
- context_switch(prev, next);
+ context_switch(prev->vcpu_list, next->vcpu_list);
}
void context_saved(struct vcpu *prev)
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 23/47] xen/sched: switch sched_move_irqs() to take sched_unit as parameter
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (21 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 22/47] xen/sched: switch schedule() from vcpus to sched_units Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-20 14:34 ` Jan Beulich
2019-09-24 20:43 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 24/47] xen: switch from for_each_vcpu() to for_each_sched_unit() Juergen Gross
` (25 subsequent siblings)
48 siblings, 2 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Dario Faggioli
sched_move_irqs() should work on a sched_unit as that is the unit
moved between cpus.
Rename the current function to vcpu_move_irqs() as it is still needed
in schedule().
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/schedule.c | 18 +++++++++++++-----
1 file changed, 13 insertions(+), 5 deletions(-)
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 2272192d49..9c41b2dd4d 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -474,12 +474,20 @@ int sched_init_vcpu(struct vcpu *v)
return 0;
}
-static void sched_move_irqs(struct vcpu *v)
+static void vcpu_move_irqs(struct vcpu *v)
{
arch_move_irqs(v);
evtchn_move_pirqs(v);
}
+static void sched_move_irqs(struct sched_unit *unit)
+{
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ vcpu_move_irqs(v);
+}
+
int sched_move_domain(struct domain *d, struct cpupool *c)
{
struct vcpu *v;
@@ -559,7 +567,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
v->sched_unit->priv = vcpu_priv[v->vcpu_id];
if ( !d->is_dying )
- sched_move_irqs(v);
+ sched_move_irqs(v->sched_unit);
new_p = cpumask_cycle(new_p, c->cpu_valid);
@@ -852,7 +860,7 @@ static void vcpu_migrate_finish(struct vcpu *v)
sched_spin_unlock_double(old_lock, new_lock, flags);
if ( old_cpu != new_cpu )
- sched_move_irqs(v);
+ sched_move_irqs(v->sched_unit);
/* Wake on new CPU. */
vcpu_wake(v);
@@ -917,7 +925,7 @@ void restore_vcpu_affinity(struct domain *d)
spin_unlock_irq(lock);
if ( old_cpu != v->processor )
- sched_move_irqs(v);
+ sched_move_irqs(v->sched_unit);
}
domain_update_node_affinity(d);
@@ -1736,7 +1744,7 @@ static void schedule(void)
stop_timer(&prev->vcpu_list->periodic_timer);
if ( next_slice.migrated )
- sched_move_irqs(next->vcpu_list);
+ vcpu_move_irqs(next->vcpu_list);
vcpu_periodic_timer_work(next->vcpu_list);
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 24/47] xen: switch from for_each_vcpu() to for_each_sched_unit()
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (22 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 23/47] xen/sched: switch sched_move_irqs() to take sched_unit as parameter Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-20 15:05 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 25/47] xen/sched: add runstate counters to struct sched_unit Juergen Gross
` (24 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Tim Deegan, Julien Grall, Jan Beulich, Dario Faggioli
Where appropriate switch from for_each_vcpu() to for_each_sched_unit()
in order to prepare core scheduling.
As it is beneficial once here and for sure in future add a
unit_scheduler() helper and let vcpu_scheduler() use it.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V2:
- handle affinity_broken correctly (Jan Beulich)
- add unit_scheduler() (Jan Beulich)
V3:
- add const (Jan Beulich)
- add TODOs for missing multiple vcpu per unit support (Jan Beulich)
---
xen/common/domain.c | 9 ++-
xen/common/schedule.c | 158 +++++++++++++++++++++++++++++++-------------------
2 files changed, 103 insertions(+), 64 deletions(-)
diff --git a/xen/common/domain.c b/xen/common/domain.c
index a3e23f2ee7..7a1be85be9 100644
--- a/xen/common/domain.c
+++ b/xen/common/domain.c
@@ -554,7 +554,7 @@ void domain_update_node_affinity(struct domain *d)
cpumask_var_t dom_cpumask, dom_cpumask_soft;
cpumask_t *dom_affinity;
const cpumask_t *online;
- struct vcpu *v;
+ struct sched_unit *unit;
unsigned int cpu;
/* Do we have vcpus already? If not, no need to update node-affinity. */
@@ -587,12 +587,11 @@ void domain_update_node_affinity(struct domain *d)
* and the full mask of where it would prefer to run (the union of
* the soft affinity of all its various vcpus). Let's build them.
*/
- for_each_vcpu ( d, v )
+ for_each_sched_unit ( d, unit )
{
- cpumask_or(dom_cpumask, dom_cpumask,
- v->sched_unit->cpu_hard_affinity);
+ cpumask_or(dom_cpumask, dom_cpumask, unit->cpu_hard_affinity);
cpumask_or(dom_cpumask_soft, dom_cpumask_soft,
- v->sched_unit->cpu_soft_affinity);
+ unit->cpu_soft_affinity);
}
/* Filter out non-online cpus */
cpumask_and(dom_cpumask, dom_cpumask, online);
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 9c41b2dd4d..7b37461db9 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -150,26 +150,32 @@ static inline struct scheduler *dom_scheduler(const struct domain *d)
return &ops;
}
-static inline struct scheduler *vcpu_scheduler(const struct vcpu *v)
+static inline struct scheduler *unit_scheduler(const struct sched_unit *unit)
{
- struct domain *d = v->domain;
+ struct domain *d = unit->domain;
if ( likely(d->cpupool != NULL) )
return d->cpupool->sched;
/*
- * If d->cpupool is NULL, this is a vCPU of the idle domain. And this
+ * If d->cpupool is NULL, this is a unit of the idle domain. And this
* case is special because the idle domain does not really belong to
* a cpupool and, hence, doesn't really have a scheduler). In fact, its
- * vCPUs (may) run on pCPUs which are in different pools, with different
+ * units (may) run on pCPUs which are in different pools, with different
* schedulers.
*
* What we want, in this case, is the scheduler of the pCPU where this
- * particular idle vCPU is running. And, since v->processor never changes
- * for idle vCPUs, it is safe to use it, with no locks, to figure that out.
+ * particular idle unit is running. And, since unit->res never changes
+ * for idle units, it is safe to use it, with no locks, to figure that out.
*/
+
ASSERT(is_idle_domain(d));
- return per_cpu(scheduler, v->processor);
+ return per_cpu(scheduler, unit->res->master_cpu);
+}
+
+static inline struct scheduler *vcpu_scheduler(const struct vcpu *v)
+{
+ return unit_scheduler(v->sched_unit);
}
#define VCPU2ONLINE(_v) cpupool_domain_cpumask((_v)->domain)
@@ -491,10 +497,11 @@ static void sched_move_irqs(struct sched_unit *unit)
int sched_move_domain(struct domain *d, struct cpupool *c)
{
struct vcpu *v;
- unsigned int new_p;
- void **vcpu_priv;
+ struct sched_unit *unit;
+ unsigned int new_p, unit_idx;
+ void **unit_priv;
void *domdata;
- void *vcpudata;
+ void *unitdata;
struct scheduler *old_ops;
void *old_domdata;
@@ -508,25 +515,27 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
if ( IS_ERR(domdata) )
return PTR_ERR(domdata);
- vcpu_priv = xzalloc_array(void *, d->max_vcpus);
- if ( vcpu_priv == NULL )
+ /* TODO: fix array size with multiple vcpus per unit. */
+ unit_priv = xzalloc_array(void *, d->max_vcpus);
+ if ( unit_priv == NULL )
{
sched_free_domdata(c->sched, domdata);
return -ENOMEM;
}
- for_each_vcpu ( d, v )
+ unit_idx = 0;
+ for_each_sched_unit ( d, unit )
{
- vcpu_priv[v->vcpu_id] = sched_alloc_vdata(c->sched, v->sched_unit,
- domdata);
- if ( vcpu_priv[v->vcpu_id] == NULL )
+ unit_priv[unit_idx] = sched_alloc_vdata(c->sched, unit, domdata);
+ if ( unit_priv[unit_idx] == NULL )
{
- for_each_vcpu ( d, v )
- xfree(vcpu_priv[v->vcpu_id]);
- xfree(vcpu_priv);
+ for ( unit_idx = 0; unit_priv[unit_idx]; unit_idx++ )
+ sched_free_vdata(c->sched, unit_priv[unit_idx]);
+ xfree(unit_priv);
sched_free_domdata(c->sched, domdata);
return -ENOMEM;
}
+ unit_idx++;
}
domain_pause(d);
@@ -534,30 +543,36 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
old_ops = dom_scheduler(d);
old_domdata = d->sched_priv;
- for_each_vcpu ( d, v )
+ for_each_sched_unit ( d, unit )
{
- sched_remove_unit(old_ops, v->sched_unit);
+ sched_remove_unit(old_ops, unit);
}
d->cpupool = c;
d->sched_priv = domdata;
new_p = cpumask_first(c->cpu_valid);
- for_each_vcpu ( d, v )
+ unit_idx = 0;
+ for_each_sched_unit ( d, unit )
{
spinlock_t *lock;
+ unsigned int unit_p = new_p;
- vcpudata = v->sched_unit->priv;
+ unitdata = unit->priv;
- migrate_timer(&v->periodic_timer, new_p);
- migrate_timer(&v->singleshot_timer, new_p);
- migrate_timer(&v->poll_timer, new_p);
+ for_each_sched_unit_vcpu ( unit, v )
+ {
+ migrate_timer(&v->periodic_timer, new_p);
+ migrate_timer(&v->singleshot_timer, new_p);
+ migrate_timer(&v->poll_timer, new_p);
+ new_p = cpumask_cycle(new_p, c->cpu_valid);
+ }
- lock = unit_schedule_lock_irq(v->sched_unit);
+ lock = unit_schedule_lock_irq(unit);
- sched_set_affinity(v, &cpumask_all, &cpumask_all);
+ sched_set_affinity(unit->vcpu_list, &cpumask_all, &cpumask_all);
- sched_set_res(v->sched_unit, get_sched_res(new_p));
+ sched_set_res(unit, get_sched_res(unit_p));
/*
* With v->processor modified we must not
* - make any further changes assuming we hold the scheduler lock,
@@ -565,15 +580,15 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
*/
spin_unlock_irq(lock);
- v->sched_unit->priv = vcpu_priv[v->vcpu_id];
+ unit->priv = unit_priv[unit_idx];
if ( !d->is_dying )
- sched_move_irqs(v->sched_unit);
+ sched_move_irqs(unit);
- new_p = cpumask_cycle(new_p, c->cpu_valid);
+ sched_insert_unit(c->sched, unit);
- sched_insert_unit(c->sched, v->sched_unit);
+ sched_free_vdata(old_ops, unitdata);
- sched_free_vdata(old_ops, vcpudata);
+ unit_idx++;
}
domain_update_node_affinity(d);
@@ -582,7 +597,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
sched_free_domdata(old_ops, old_domdata);
- xfree(vcpu_priv);
+ xfree(unit_priv);
return 0;
}
@@ -866,18 +881,36 @@ static void vcpu_migrate_finish(struct vcpu *v)
vcpu_wake(v);
}
+static bool sched_check_affinity_broken(const struct sched_unit *unit)
+{
+ const struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ if ( v->affinity_broken )
+ return true;
+
+ return false;
+}
+
+static void sched_reset_affinity_broken(struct sched_unit *unit)
+{
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ v->affinity_broken = false;
+}
+
void restore_vcpu_affinity(struct domain *d)
{
unsigned int cpu = smp_processor_id();
- struct vcpu *v;
+ struct sched_unit *unit;
ASSERT(system_state == SYS_STATE_resume);
- for_each_vcpu ( d, v )
+ for_each_sched_unit ( d, unit )
{
spinlock_t *lock;
- unsigned int old_cpu = v->processor;
- struct sched_unit *unit = v->sched_unit;
+ unsigned int old_cpu = sched_unit_cpu(unit);
struct sched_resource *res;
ASSERT(!unit_runnable(unit));
@@ -896,18 +929,22 @@ void restore_vcpu_affinity(struct domain *d)
cpupool_domain_cpumask(d));
if ( cpumask_empty(cpumask_scratch_cpu(cpu)) )
{
- if ( v->affinity_broken )
+ if ( sched_check_affinity_broken(unit) )
{
- sched_set_affinity(v, unit->cpu_hard_affinity_saved, NULL);
- v->affinity_broken = 0;
+ /* Affinity settings of one vcpu are for the complete unit. */
+ sched_set_affinity(unit->vcpu_list,
+ unit->cpu_hard_affinity_saved, NULL);
+ sched_reset_affinity_broken(unit);
cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
cpupool_domain_cpumask(d));
}
if ( cpumask_empty(cpumask_scratch_cpu(cpu)) )
{
- printk(XENLOG_DEBUG "Breaking affinity for %pv\n", v);
- sched_set_affinity(v, &cpumask_all, NULL);
+ /* Affinity settings of one vcpu are for the complete unit. */
+ printk(XENLOG_DEBUG "Breaking affinity for %pv\n",
+ unit->vcpu_list);
+ sched_set_affinity(unit->vcpu_list, &cpumask_all, NULL);
cpumask_and(cpumask_scratch_cpu(cpu), unit->cpu_hard_affinity,
cpupool_domain_cpumask(d));
}
@@ -920,12 +957,12 @@ void restore_vcpu_affinity(struct domain *d)
/* v->processor might have changed, so reacquire the lock. */
lock = unit_schedule_lock_irq(unit);
- res = sched_pick_resource(vcpu_scheduler(v), unit);
+ res = sched_pick_resource(unit_scheduler(unit), unit);
sched_set_res(unit, res);
spin_unlock_irq(lock);
- if ( old_cpu != v->processor )
- sched_move_irqs(v->sched_unit);
+ if ( old_cpu != sched_unit_cpu(unit) )
+ sched_move_irqs(unit);
}
domain_update_node_affinity(d);
@@ -939,7 +976,6 @@ void restore_vcpu_affinity(struct domain *d)
int cpu_disable_scheduler(unsigned int cpu)
{
struct domain *d;
- struct vcpu *v;
struct cpupool *c;
cpumask_t online_affinity;
int ret = 0;
@@ -950,17 +986,19 @@ int cpu_disable_scheduler(unsigned int cpu)
for_each_domain_in_cpupool ( d, c )
{
- for_each_vcpu ( d, v )
+ struct sched_unit *unit;
+
+ for_each_sched_unit ( d, unit )
{
unsigned long flags;
- struct sched_unit *unit = v->sched_unit;
spinlock_t *lock = unit_schedule_lock_irqsave(unit, &flags);
cpumask_and(&online_affinity, unit->cpu_hard_affinity, c->cpu_valid);
if ( cpumask_empty(&online_affinity) &&
cpumask_test_cpu(cpu, unit->cpu_hard_affinity) )
{
- if ( v->affinity_broken )
+ /* TODO: multiple vcpus per unit. */
+ if ( unit->vcpu_list->affinity_broken )
{
/* The vcpu is temporarily pinned, can't move it. */
unit_schedule_unlock_irqrestore(lock, flags, unit);
@@ -968,14 +1006,15 @@ int cpu_disable_scheduler(unsigned int cpu)
break;
}
- printk(XENLOG_DEBUG "Breaking affinity for %pv\n", v);
+ printk(XENLOG_DEBUG "Breaking affinity for %pv\n",
+ unit->vcpu_list);
- sched_set_affinity(v, &cpumask_all, NULL);
+ sched_set_affinity(unit->vcpu_list, &cpumask_all, NULL);
}
- if ( v->processor != cpu )
+ if ( sched_unit_cpu(unit) != sched_get_resource_cpu(cpu) )
{
- /* The vcpu is not on this cpu, so we can move on. */
+ /* The unit is not on this cpu, so we can move on. */
unit_schedule_unlock_irqrestore(lock, flags, unit);
continue;
}
@@ -988,17 +1027,18 @@ int cpu_disable_scheduler(unsigned int cpu)
* * the scheduler will always find a suitable solution, or
* things would have failed before getting in here.
*/
- vcpu_migrate_start(v);
+ /* TODO: multiple vcpus per unit. */
+ vcpu_migrate_start(unit->vcpu_list);
unit_schedule_unlock_irqrestore(lock, flags, unit);
- vcpu_migrate_finish(v);
+ vcpu_migrate_finish(unit->vcpu_list);
/*
* The only caveat, in this case, is that if a vcpu active in
* the hypervisor isn't migratable. In this case, the caller
* should try again after releasing and reaquiring all locks.
*/
- if ( v->processor == cpu )
+ if ( sched_unit_cpu(unit) == sched_get_resource_cpu(cpu) )
ret = -EAGAIN;
}
}
@@ -1009,8 +1049,8 @@ int cpu_disable_scheduler(unsigned int cpu)
static int cpu_disable_scheduler_check(unsigned int cpu)
{
struct domain *d;
- struct vcpu *v;
struct cpupool *c;
+ struct vcpu *v;
c = per_cpu(cpupool, cpu);
if ( c == NULL )
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 25/47] xen/sched: add runstate counters to struct sched_unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (23 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 24/47] xen: switch from for_each_vcpu() to for_each_sched_unit() Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-20 15:27 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 26/47] xen/sched: Change vcpu_migrate_*() to operate on schedule unit Juergen Gross
` (23 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
Add counters to struct sched_unit summing up runstates of associated
vcpus. This allows doing quick checks whether a unit has any vcpu
running or whether only a single vcpu of a unit is running.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
RFC V2: add counters for each possible runstate
---
xen/common/schedule.c | 8 +++++++-
xen/include/xen/sched.h | 2 ++
2 files changed, 9 insertions(+), 1 deletion(-)
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 7b37461db9..0bd9f0d278 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -239,6 +239,7 @@ static inline void vcpu_runstate_change(
struct vcpu *v, int new_state, s_time_t new_entry_time)
{
s_time_t delta;
+ struct sched_unit *unit = v->sched_unit;
ASSERT(v->runstate.state != new_state);
ASSERT(spin_is_locked(get_sched_res(v->processor)->schedule_lock));
@@ -247,6 +248,9 @@ static inline void vcpu_runstate_change(
trace_runstate_change(v, new_state);
+ unit->runstate_cnt[v->runstate.state]--;
+ unit->runstate_cnt[new_state]++;
+
delta = new_entry_time - v->runstate.state_entry_time;
if ( delta > 0 )
{
@@ -368,7 +372,7 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
unit->vcpu_list = v;
unit->unit_id = v->vcpu_id;
unit->domain = d;
- v->sched_unit = unit;
+ unit->runstate_cnt[v->runstate.state]++;
for ( prev_unit = &d->sched_unit_list; *prev_unit;
prev_unit = &(*prev_unit)->next_in_list )
@@ -384,6 +388,8 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
!zalloc_cpumask_var(&unit->cpu_soft_affinity) )
goto fail;
+ v->sched_unit = unit;
+
return unit;
fail:
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 56ed863b08..36257a06fe 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -277,6 +277,8 @@ struct sched_unit {
/* Last time unit got (de-)scheduled. */
uint64_t state_entry_time;
+ /* Vcpu state summary. */
+ unsigned int runstate_cnt[4];
/* Bitmask of CPUs on which this VCPU may run. */
cpumask_var_t cpu_hard_affinity;
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 26/47] xen/sched: Change vcpu_migrate_*() to operate on schedule unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (24 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 25/47] xen/sched: add runstate counters to struct sched_unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 22:33 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 27/47] xen/sched: move struct task_slice into struct sched_unit Juergen Gross
` (22 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Dario Faggioli
Now that vcpu_migrate_start() and vcpu_migrate_finish() are used only
to ensure a vcpu is running on a suitable processor they can be
switched to operate on schedule units instead of vcpus.
While doing that rename them accordingly and make the _start() variant
static. As it is needed anyway call vcpu_sync_execstate() for each
vcpu of the unit when changing processors.
vcpu_move_locked() is switched to schedule unit, too.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V3:
- move tested invariant condition out of loop (Jan Beulich)
- add comment regarding call of vcpu_sync_execstate() (Jan Beulich)
---
xen/common/schedule.c | 106 +++++++++++++++++++++++++++++++-------------------
1 file changed, 65 insertions(+), 41 deletions(-)
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 0bd9f0d278..70271cdea2 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -744,35 +744,40 @@ void vcpu_unblock(struct vcpu *v)
}
/*
- * Do the actual movement of a vcpu from old to new CPU. Locks for *both*
+ * Do the actual movement of an unit from old to new CPU. Locks for *both*
* CPUs needs to have been taken already when calling this!
*/
-static void vcpu_move_locked(struct vcpu *v, unsigned int new_cpu)
+static void sched_unit_move_locked(struct sched_unit *unit,
+ unsigned int new_cpu)
{
- unsigned int old_cpu = v->processor;
+ unsigned int old_cpu = unit->res->master_cpu;
+ struct vcpu *v;
/*
* Transfer urgency status to new CPU before switching CPUs, as
* once the switch occurs, v->is_urgent is no longer protected by
* the per-CPU scheduler lock we are holding.
*/
- if ( unlikely(v->is_urgent) && (old_cpu != new_cpu) )
+ for_each_sched_unit_vcpu ( unit, v )
{
- atomic_inc(&per_cpu(sched_urgent_count, new_cpu));
- atomic_dec(&per_cpu(sched_urgent_count, old_cpu));
+ if ( unlikely(v->is_urgent) && (old_cpu != new_cpu) )
+ {
+ atomic_inc(&per_cpu(sched_urgent_count, new_cpu));
+ atomic_dec(&per_cpu(sched_urgent_count, old_cpu));
+ }
}
/*
* Actual CPU switch to new CPU. This is safe because the lock
* pointer can't change while the current lock is held.
*/
- sched_migrate(vcpu_scheduler(v), v->sched_unit, new_cpu);
+ sched_migrate(unit_scheduler(unit), unit, new_cpu);
}
/*
* Initiating migration
*
- * In order to migrate, we need the vcpu in question to have stopped
+ * In order to migrate, we need the unit in question to have stopped
* running and had sched_sleep() called (to take it off any
* runqueues, for instance); and if it is currently running, it needs
* to be scheduled out. Finally, we need to hold the scheduling locks
@@ -788,37 +793,45 @@ static void vcpu_move_locked(struct vcpu *v, unsigned int new_cpu)
* should be called like this:
*
* lock = unit_schedule_lock_irq(unit);
- * vcpu_migrate_start(v);
+ * sched_unit_migrate_start(unit);
* unit_schedule_unlock_irq(lock, unit)
- * vcpu_migrate_finish(v);
+ * sched_unit_migrate_finish(unit);
*
- * vcpu_migrate_finish() will do the work now if it can, or simply
- * return if it can't (because v is still running); in that case
- * vcpu_migrate_finish() will be called by context_saved().
+ * sched_unit_migrate_finish() will do the work now if it can, or simply
+ * return if it can't (because unit is still running); in that case
+ * sched_unit_migrate_finish() will be called by context_saved().
*/
-static void vcpu_migrate_start(struct vcpu *v)
+static void sched_unit_migrate_start(struct sched_unit *unit)
{
- set_bit(_VPF_migrating, &v->pause_flags);
- vcpu_sleep_nosync_locked(v);
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ {
+ set_bit(_VPF_migrating, &v->pause_flags);
+ vcpu_sleep_nosync_locked(v);
+ }
}
-static void vcpu_migrate_finish(struct vcpu *v)
+static void sched_unit_migrate_finish(struct sched_unit *unit)
{
unsigned long flags;
unsigned int old_cpu, new_cpu;
spinlock_t *old_lock, *new_lock;
bool_t pick_called = 0;
+ struct vcpu *v;
/*
- * If the vcpu is currently running, this will be handled by
+ * If the unit is currently running, this will be handled by
* context_saved(); and in any case, if the bit is cleared, then
* someone else has already done the work so we don't need to.
*/
- if ( v->sched_unit->is_running ||
- !test_bit(_VPF_migrating, &v->pause_flags) )
+ if ( unit->is_running )
return;
+ for_each_sched_unit_vcpu ( unit, v )
+ if ( !test_bit(_VPF_migrating, &v->pause_flags) )
+ return;
- old_cpu = new_cpu = v->processor;
+ old_cpu = new_cpu = unit->res->master_cpu;
for ( ; ; )
{
/*
@@ -831,7 +844,7 @@ static void vcpu_migrate_finish(struct vcpu *v)
sched_spin_lock_double(old_lock, new_lock, &flags);
- old_cpu = v->processor;
+ old_cpu = unit->res->master_cpu;
if ( old_lock == get_sched_res(old_cpu)->schedule_lock )
{
/*
@@ -840,15 +853,15 @@ static void vcpu_migrate_finish(struct vcpu *v)
*/
if ( pick_called &&
(new_lock == get_sched_res(new_cpu)->schedule_lock) &&
- cpumask_test_cpu(new_cpu, v->sched_unit->cpu_hard_affinity) &&
- cpumask_test_cpu(new_cpu, v->domain->cpupool->cpu_valid) )
+ cpumask_test_cpu(new_cpu, unit->cpu_hard_affinity) &&
+ cpumask_test_cpu(new_cpu, unit->domain->cpupool->cpu_valid) )
break;
/* Select a new CPU. */
- new_cpu = sched_pick_resource(vcpu_scheduler(v),
- v->sched_unit)->master_cpu;
+ new_cpu = sched_pick_resource(unit_scheduler(unit),
+ unit)->master_cpu;
if ( (new_lock == get_sched_res(new_cpu)->schedule_lock) &&
- cpumask_test_cpu(new_cpu, v->domain->cpupool->cpu_valid) )
+ cpumask_test_cpu(new_cpu, unit->domain->cpupool->cpu_valid) )
break;
pick_called = 1;
}
@@ -869,22 +882,35 @@ static void vcpu_migrate_finish(struct vcpu *v)
* because they both happen in (different) spinlock regions, and those
* regions are strictly serialised.
*/
- if ( v->sched_unit->is_running ||
- !test_and_clear_bit(_VPF_migrating, &v->pause_flags) )
+ if ( unit->is_running )
{
sched_spin_unlock_double(old_lock, new_lock, flags);
return;
}
+ for_each_sched_unit_vcpu ( unit, v )
+ {
+ if ( !test_and_clear_bit(_VPF_migrating, &v->pause_flags) )
+ {
+ sched_spin_unlock_double(old_lock, new_lock, flags);
+ return;
+ }
+ }
- vcpu_move_locked(v, new_cpu);
+ sched_unit_move_locked(unit, new_cpu);
sched_spin_unlock_double(old_lock, new_lock, flags);
if ( old_cpu != new_cpu )
- sched_move_irqs(v->sched_unit);
+ {
+ /* Vcpus are moved to other pcpus, commit their states to memory. */
+ for_each_sched_unit_vcpu ( unit, v )
+ sync_vcpu_execstate(v);
+ sched_move_irqs(unit);
+ }
/* Wake on new CPU. */
- vcpu_wake(v);
+ for_each_sched_unit_vcpu ( unit, v )
+ vcpu_wake(v);
}
static bool sched_check_affinity_broken(const struct sched_unit *unit)
@@ -1033,11 +1059,9 @@ int cpu_disable_scheduler(unsigned int cpu)
* * the scheduler will always find a suitable solution, or
* things would have failed before getting in here.
*/
- /* TODO: multiple vcpus per unit. */
- vcpu_migrate_start(unit->vcpu_list);
+ sched_unit_migrate_start(unit);
unit_schedule_unlock_irqrestore(lock, flags, unit);
-
- vcpu_migrate_finish(unit->vcpu_list);
+ sched_unit_migrate_finish(unit);
/*
* The only caveat, in this case, is that if a vcpu active in
@@ -1121,14 +1145,14 @@ static int vcpu_set_affinity(
ASSERT(which == unit->cpu_soft_affinity);
sched_set_affinity(v, NULL, affinity);
}
- vcpu_migrate_start(v);
+ sched_unit_migrate_start(unit);
}
unit_schedule_unlock_irq(lock, unit);
domain_update_node_affinity(v->domain);
- vcpu_migrate_finish(v);
+ sched_unit_migrate_finish(unit);
return ret;
}
@@ -1389,12 +1413,12 @@ int vcpu_temporary_affinity(struct vcpu *v, unsigned int cpu, uint8_t reason)
migrate = !ret && !cpumask_test_cpu(v->processor, unit->cpu_hard_affinity);
if ( migrate )
- vcpu_migrate_start(v);
+ sched_unit_migrate_start(unit);
unit_schedule_unlock_irq(lock, unit);
if ( migrate )
- vcpu_migrate_finish(v);
+ sched_unit_migrate_finish(unit);
return ret;
}
@@ -1811,7 +1835,7 @@ void context_saved(struct vcpu *prev)
sched_context_saved(vcpu_scheduler(prev), prev->sched_unit);
- vcpu_migrate_finish(prev);
+ sched_unit_migrate_finish(prev->sched_unit);
}
/* The scheduler timer: force a run through the scheduler */
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 27/47] xen/sched: move struct task_slice into struct sched_unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (25 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 26/47] xen/sched: Change vcpu_migrate_*() to operate on schedule unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-26 10:30 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 28/47] xen/sched: add code to sync scheduling of all vcpus of a sched unit Juergen Gross
` (21 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Robert VanVossen, Dario Faggioli, Julien Grall, Josh Whitehead,
Meng Xu, Jan Beulich
In order to prepare for multiple vcpus per schedule unit move struct
task_slice in schedule() from the local stack into struct sched_unit
of the currently running unit. To make access easier for the single
schedulers add the pointer of the currently running unit as a parameter
of do_schedule().
While at it switch the tasklet_work_scheduled parameter of
do_schedule() from bool_t to bool.
As struct task_slice is only ever modified with the local schedule
lock held it is safe to directly set the different units in struct
sched_unit instead of using an on-stack copy for returning the data.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V3:
- readd accidentally dropped call of continue_running() (Dario Faggioli)
---
xen/common/sched_arinc653.c | 20 +++++++-------------
xen/common/sched_credit.c | 25 +++++++++++--------------
xen/common/sched_credit2.c | 21 +++++++++------------
xen/common/sched_null.c | 29 ++++++++++++++---------------
xen/common/sched_rt.c | 22 +++++++++++-----------
xen/common/schedule.c | 30 ++++++++++++++----------------
xen/include/xen/sched-if.h | 11 +++--------
xen/include/xen/sched.h | 6 ++++++
8 files changed, 75 insertions(+), 89 deletions(-)
diff --git a/xen/common/sched_arinc653.c b/xen/common/sched_arinc653.c
index a4db34843b..96f3e844d2 100644
--- a/xen/common/sched_arinc653.c
+++ b/xen/common/sched_arinc653.c
@@ -497,18 +497,14 @@ a653sched_unit_wake(const struct scheduler *ops, struct sched_unit *unit)
*
* @param ops Pointer to this instance of the scheduler structure
* @param now Current time
- *
- * @return Address of the UNIT structure scheduled to be run next
- * Amount of time to execute the returned UNIT
- * Flag for whether the UNIT was migrated
*/
-static struct task_slice
+static void
a653sched_do_schedule(
const struct scheduler *ops,
+ struct sched_unit *prev,
s_time_t now,
- bool_t tasklet_work_scheduled)
+ bool tasklet_work_scheduled)
{
- struct task_slice ret; /* hold the chosen domain */
struct sched_unit *new_task = NULL;
static unsigned int sched_index = 0;
static s_time_t next_switch_time;
@@ -586,13 +582,11 @@ a653sched_do_schedule(
* Return the amount of time the next domain has to run and the address
* of the selected task's UNIT structure.
*/
- ret.time = next_switch_time - now;
- ret.task = new_task;
- ret.migrated = 0;
-
- BUG_ON(ret.time <= 0);
+ prev->next_time = next_switch_time - now;
+ prev->next_task = new_task;
+ new_task->migrated = false;
- return ret;
+ BUG_ON(prev->next_time <= 0);
}
/**
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index 203c5decef..5802a67784 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -1675,7 +1675,7 @@ csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
static struct csched_unit *
csched_load_balance(struct csched_private *prv, int cpu,
- struct csched_unit *snext, bool_t *stolen)
+ struct csched_unit *snext, bool *stolen)
{
struct cpupool *c = per_cpu(cpupool, cpu);
struct csched_unit *speer;
@@ -1791,7 +1791,7 @@ csched_load_balance(struct csched_private *prv, int cpu,
/* As soon as one unit is found, balancing ends */
if ( speer != NULL )
{
- *stolen = 1;
+ *stolen = true;
/*
* Next time we'll look for work to steal on this node, we
* will start from the next pCPU, with respect to this one,
@@ -1821,19 +1821,18 @@ csched_load_balance(struct csched_private *prv, int cpu,
* This function is in the critical path. It is designed to be simple and
* fast for the common case.
*/
-static struct task_slice
-csched_schedule(
- const struct scheduler *ops, s_time_t now, bool_t tasklet_work_scheduled)
+static void csched_schedule(
+ const struct scheduler *ops, struct sched_unit *unit, s_time_t now,
+ bool tasklet_work_scheduled)
{
const unsigned int cur_cpu = smp_processor_id();
const unsigned int sched_cpu = sched_get_resource_cpu(cur_cpu);
struct list_head * const runq = RUNQ(sched_cpu);
- struct sched_unit *unit = current->sched_unit;
struct csched_unit * const scurr = CSCHED_UNIT(unit);
struct csched_private *prv = CSCHED_PRIV(ops);
struct csched_unit *snext;
- struct task_slice ret;
s_time_t runtime, tslice;
+ bool migrated = false;
SCHED_STAT_CRANK(schedule);
CSCHED_UNIT_CHECK(unit);
@@ -1924,7 +1923,6 @@ csched_schedule(
(unsigned char *)&d);
}
- ret.migrated = 0;
goto out;
}
tslice = prv->tslice;
@@ -1942,7 +1940,6 @@ csched_schedule(
}
snext = __runq_elem(runq->next);
- ret.migrated = 0;
/* Tasklet work (which runs in idle UNIT context) overrides all else. */
if ( tasklet_work_scheduled )
@@ -1968,7 +1965,7 @@ csched_schedule(
if ( snext->pri > CSCHED_PRI_TS_OVER )
__runq_remove(snext);
else
- snext = csched_load_balance(prv, sched_cpu, snext, &ret.migrated);
+ snext = csched_load_balance(prv, sched_cpu, snext, &migrated);
/*
* Update idlers mask if necessary. When we're idling, other CPUs
@@ -1991,12 +1988,12 @@ out:
/*
* Return task to run next...
*/
- ret.time = (is_idle_unit(snext->unit) ?
+ unit->next_time = (is_idle_unit(snext->unit) ?
-1 : tslice);
- ret.task = snext->unit;
+ unit->next_task = snext->unit;
+ snext->unit->migrated = migrated;
- CSCHED_UNIT_CHECK(ret.task);
- return ret;
+ CSCHED_UNIT_CHECK(unit->next_task);
}
static void
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index cf0559e964..414ac8f5b6 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -3444,19 +3444,18 @@ runq_candidate(struct csched2_runqueue_data *rqd,
* This function is in the critical path. It is designed to be simple and
* fast for the common case.
*/
-static struct task_slice
-csched2_schedule(
- const struct scheduler *ops, s_time_t now, bool tasklet_work_scheduled)
+static void csched2_schedule(
+ const struct scheduler *ops, struct sched_unit *currunit, s_time_t now,
+ bool tasklet_work_scheduled)
{
const unsigned int cur_cpu = smp_processor_id();
const unsigned int sched_cpu = sched_get_resource_cpu(cur_cpu);
struct csched2_runqueue_data *rqd;
- struct sched_unit *currunit = current->sched_unit;
struct csched2_unit * const scurr = csched2_unit(currunit);
struct csched2_unit *snext = NULL;
unsigned int skipped_units = 0;
- struct task_slice ret;
bool tickled;
+ bool migrated = false;
SCHED_STAT_CRANK(schedule);
CSCHED2_UNIT_CHECK(currunit);
@@ -3541,8 +3540,6 @@ csched2_schedule(
&& unit_runnable(currunit) )
__set_bit(__CSFLAG_delayed_runq_add, &scurr->flags);
- ret.migrated = 0;
-
/* Accounting for non-idle tasks */
if ( !is_idle_unit(snext->unit) )
{
@@ -3592,7 +3589,7 @@ csched2_schedule(
snext->credit += CSCHED2_MIGRATE_COMPENSATION;
sched_set_res(snext->unit, get_sched_res(sched_cpu));
SCHED_STAT_CRANK(migrated);
- ret.migrated = 1;
+ migrated = true;
}
}
else
@@ -3623,11 +3620,11 @@ csched2_schedule(
/*
* Return task to run next...
*/
- ret.time = csched2_runtime(ops, sched_cpu, snext, now);
- ret.task = snext->unit;
+ currunit->next_time = csched2_runtime(ops, sched_cpu, snext, now);
+ currunit->next_task = snext->unit;
+ snext->unit->migrated = migrated;
- CSCHED2_UNIT_CHECK(ret.task);
- return ret;
+ CSCHED2_UNIT_CHECK(currunit->next_task);
}
static void
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index 4131df0db3..d7deef07b8 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -779,16 +779,14 @@ static inline void null_unit_check(struct sched_unit *unit)
* - the unit assigned to the pCPU, if there's one and it can run;
* - the idle unit, otherwise.
*/
-static struct task_slice null_schedule(const struct scheduler *ops,
- s_time_t now,
- bool_t tasklet_work_scheduled)
+static void null_schedule(const struct scheduler *ops, struct sched_unit *prev,
+ s_time_t now, bool tasklet_work_scheduled)
{
unsigned int bs;
const unsigned int cur_cpu = smp_processor_id();
const unsigned int sched_cpu = sched_get_resource_cpu(cur_cpu);
struct null_private *prv = null_priv(ops);
struct null_unit *wvc;
- struct task_slice ret;
SCHED_STAT_CRANK(schedule);
NULL_UNIT_CHECK(current->sched_unit);
@@ -816,19 +814,18 @@ static struct task_slice null_schedule(const struct scheduler *ops,
if ( tasklet_work_scheduled )
{
trace_var(TRC_SNULL_TASKLET, 1, 0, NULL);
- ret.task = sched_idle_unit(sched_cpu);
+ prev->next_task = sched_idle_unit(sched_cpu);
}
else
- ret.task = per_cpu(npc, sched_cpu).unit;
- ret.migrated = 0;
- ret.time = -1;
+ prev->next_task = per_cpu(npc, sched_cpu).unit;
+ prev->next_time = -1;
/*
* We may be new in the cpupool, or just coming back online. In which
* case, there may be units in the waitqueue that we can assign to us
* and run.
*/
- if ( unlikely(ret.task == NULL) )
+ if ( unlikely(prev->next_task == NULL) )
{
spin_lock(&prv->waitq_lock);
@@ -854,7 +851,7 @@ static struct task_slice null_schedule(const struct scheduler *ops,
{
unit_assign(prv, wvc->unit, sched_cpu);
list_del_init(&wvc->waitq_elem);
- ret.task = wvc->unit;
+ prev->next_task = wvc->unit;
goto unlock;
}
}
@@ -862,15 +859,17 @@ static struct task_slice null_schedule(const struct scheduler *ops,
unlock:
spin_unlock(&prv->waitq_lock);
- if ( ret.task == NULL && !cpumask_test_cpu(sched_cpu, &prv->cpus_free) )
+ if ( prev->next_task == NULL &&
+ !cpumask_test_cpu(sched_cpu, &prv->cpus_free) )
cpumask_set_cpu(sched_cpu, &prv->cpus_free);
}
- if ( unlikely(ret.task == NULL || !unit_runnable(ret.task)) )
- ret.task = sched_idle_unit(sched_cpu);
+ if ( unlikely(prev->next_task == NULL || !unit_runnable(prev->next_task)) )
+ prev->next_task = sched_idle_unit(sched_cpu);
- NULL_UNIT_CHECK(ret.task);
- return ret;
+ NULL_UNIT_CHECK(prev->next_task);
+
+ prev->next_task->migrated = false;
}
static inline void dump_unit(struct null_private *prv, struct null_unit *nvc)
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index ab48d4bb1d..91bc3d56fb 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -1054,16 +1054,16 @@ runq_pick(const struct scheduler *ops, const cpumask_t *mask)
* schedule function for rt scheduler.
* The lock is already grabbed in schedule.c, no need to lock here
*/
-static struct task_slice
-rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_scheduled)
+static void
+rt_schedule(const struct scheduler *ops, struct sched_unit *currunit,
+ s_time_t now, bool tasklet_work_scheduled)
{
const unsigned int cur_cpu = smp_processor_id();
const unsigned int sched_cpu = sched_get_resource_cpu(cur_cpu);
struct rt_private *prv = rt_priv(ops);
- struct rt_unit *const scurr = rt_unit(current->sched_unit);
+ struct rt_unit *const scurr = rt_unit(currunit);
struct rt_unit *snext = NULL;
- struct task_slice ret = { .migrated = 0 };
- struct sched_unit *currunit = current->sched_unit;
+ bool migrated = false;
/* TRACE */
{
@@ -1111,7 +1111,7 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
__set_bit(__RTDS_delayed_runq_add, &scurr->flags);
snext->last_start = now;
- ret.time = -1; /* if an idle unit is picked */
+ currunit->next_time = -1; /* if an idle unit is picked */
if ( !is_idle_unit(snext->unit) )
{
if ( snext != scurr )
@@ -1122,13 +1122,13 @@ rt_schedule(const struct scheduler *ops, s_time_t now, bool_t tasklet_work_sched
if ( sched_unit_cpu(snext->unit) != sched_cpu )
{
sched_set_res(snext->unit, get_sched_res(sched_cpu));
- ret.migrated = 1;
+ migrated = true;
}
- ret.time = snext->cur_budget; /* invoke the scheduler next time */
+ /* Invoke the scheduler next time. */
+ currunit->next_time = snext->cur_budget;
}
- ret.task = snext->unit;
-
- return ret;
+ currunit->next_task = snext->unit;
+ snext->unit->migrated = migrated;
}
/*
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 70271cdea2..aad396ee54 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -108,15 +108,14 @@ sched_idle_free_vdata(const struct scheduler *ops, void *priv)
{
}
-static struct task_slice sched_idle_schedule(
- const struct scheduler *ops, s_time_t now,
+static void sched_idle_schedule(
+ const struct scheduler *ops, struct sched_unit *unit, s_time_t now,
bool tasklet_work_scheduled)
{
const unsigned int cpu = smp_processor_id();
- struct task_slice ret = { .time = -1 };
- ret.task = sched_idle_unit(cpu);
- return ret;
+ unit->next_time = -1;
+ unit->next_task = sched_idle_unit(cpu);
}
static struct scheduler sched_idle_ops = {
@@ -1719,10 +1718,9 @@ static void schedule(void)
s_time_t now;
struct scheduler *sched;
unsigned long *tasklet_work = &this_cpu(tasklet_work_to_do);
- bool_t tasklet_work_scheduled = 0;
+ bool tasklet_work_scheduled = false;
struct sched_resource *sd;
spinlock_t *lock;
- struct task_slice next_slice;
int cpu = smp_processor_id();
ASSERT_NOT_IN_ATOMIC();
@@ -1738,12 +1736,12 @@ static void schedule(void)
set_bit(_TASKLET_scheduled, tasklet_work);
/* fallthrough */
case TASKLET_enqueued|TASKLET_scheduled:
- tasklet_work_scheduled = 1;
+ tasklet_work_scheduled = true;
break;
case TASKLET_scheduled:
clear_bit(_TASKLET_scheduled, tasklet_work);
case 0:
- /*tasklet_work_scheduled = 0;*/
+ /*tasklet_work_scheduled = false;*/
break;
default:
BUG();
@@ -1757,14 +1755,14 @@ static void schedule(void)
/* get policy-specific decision on scheduling... */
sched = this_cpu(scheduler);
- next_slice = sched->do_schedule(sched, now, tasklet_work_scheduled);
+ sched->do_schedule(sched, prev, now, tasklet_work_scheduled);
- next = next_slice.task;
+ next = prev->next_task;
sd->curr = next;
- if ( next_slice.time >= 0 ) /* -ve means no limit */
- set_timer(&sd->s_timer, now + next_slice.time);
+ if ( prev->next_time >= 0 ) /* -ve means no limit */
+ set_timer(&sd->s_timer, now + prev->next_time);
if ( unlikely(prev == next) )
{
@@ -1772,7 +1770,7 @@ static void schedule(void)
TRACE_4D(TRC_SCHED_SWITCH_INFCONT,
next->domain->domain_id, next->unit_id,
now - prev->state_entry_time,
- next_slice.time);
+ prev->next_time);
trace_continue_running(next->vcpu_list);
return continue_running(prev->vcpu_list);
}
@@ -1784,7 +1782,7 @@ static void schedule(void)
next->domain->domain_id, next->unit_id,
(next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
(now - next->state_entry_time) : 0,
- next_slice.time);
+ prev->next_time);
ASSERT(prev->vcpu_list->runstate.state == RUNSTATE_running);
@@ -1813,7 +1811,7 @@ static void schedule(void)
stop_timer(&prev->vcpu_list->periodic_timer);
- if ( next_slice.migrated )
+ if ( next->migrated )
vcpu_move_irqs(next->vcpu_list);
vcpu_periodic_timer_work(next->vcpu_list);
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 8429e9e287..4e89a1e640 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -196,12 +196,6 @@ static inline spinlock_t *pcpu_schedule_trylock(unsigned int cpu)
return NULL;
}
-struct task_slice {
- struct sched_unit *task;
- s_time_t time;
- bool_t migrated;
-};
-
struct scheduler {
char *name; /* full name for this scheduler */
char *opt_name; /* option name for this scheduler */
@@ -244,8 +238,9 @@ struct scheduler {
void (*context_saved) (const struct scheduler *,
struct sched_unit *);
- struct task_slice (*do_schedule) (const struct scheduler *, s_time_t,
- bool_t tasklet_work_scheduled);
+ void (*do_schedule) (const struct scheduler *,
+ struct sched_unit *, s_time_t,
+ bool tasklet_work_scheduled);
struct sched_resource *(*pick_resource)(const struct scheduler *,
const struct sched_unit *);
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 36257a06fe..a8164d873c 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -274,6 +274,8 @@ struct sched_unit {
bool is_running;
/* Does soft affinity actually play a role (given hard affinity)? */
bool soft_aff_effective;
+ /* Item has been migrated to other cpu(s). */
+ bool migrated;
/* Last time unit got (de-)scheduled. */
uint64_t state_entry_time;
@@ -286,6 +288,10 @@ struct sched_unit {
cpumask_var_t cpu_hard_affinity_saved;
/* Bitmask of CPUs on which this VCPU prefers to run. */
cpumask_var_t cpu_soft_affinity;
+
+ /* Next unit to run. */
+ struct sched_unit *next_task;
+ s_time_t next_time;
};
#define for_each_sched_unit(d, e) \
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 28/47] xen/sched: add code to sync scheduling of all vcpus of a sched unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (26 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 27/47] xen/sched: move struct task_slice into struct sched_unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-20 16:08 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 29/47] xen/sched: introduce unit_runnable_state() Juergen Gross
` (20 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Tim Deegan, Julien Grall, Jan Beulich, Dario Faggioli,
Volodymyr Babchuk, Roger Pau Monné
When switching sched units synchronize all vcpus of the new unit to be
scheduled at the same time.
A variable sched_granularity is added which holds the number of vcpus
per schedule unit.
As tasklets require to schedule the idle unit it is required to set the
tasklet_work_scheduled parameter of do_schedule() to true if any cpu
covered by the current schedule() call has any pending tasklet work.
For joining other vcpus of the schedule unit we need to add a new
softirq SCHED_SLAVE_SOFTIRQ in order to have a way to initiate a
context switch without calling the generic schedule() function
selecting the vcpu to switch to, as we already know which vcpu we
want to run. This has the other advantage not to loose any other
concurrent SCHEDULE_SOFTIRQ events.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
RFC V2:
- move syncing after context_switch() to schedule.c
V2:
- don't run tasklets directly from sched_wait_rendezvous_in()
V3:
- adapt array size in sched_move_domain() (Jan Beulich)
- int -> unsigned int (Jan Beulich)
---
xen/arch/arm/domain.c | 2 +-
xen/arch/x86/domain.c | 3 +-
xen/common/schedule.c | 345 +++++++++++++++++++++++++++++++++++----------
xen/common/softirq.c | 6 +-
xen/include/xen/sched-if.h | 1 +
xen/include/xen/sched.h | 16 ++-
xen/include/xen/softirq.h | 1 +
7 files changed, 287 insertions(+), 87 deletions(-)
diff --git a/xen/arch/arm/domain.c b/xen/arch/arm/domain.c
index a9c4113c26..c8efef4179 100644
--- a/xen/arch/arm/domain.c
+++ b/xen/arch/arm/domain.c
@@ -315,7 +315,7 @@ static void schedule_tail(struct vcpu *prev)
local_irq_enable();
- context_saved(prev);
+ sched_context_switched(prev, current);
update_runstate_area(current);
diff --git a/xen/arch/x86/domain.c b/xen/arch/x86/domain.c
index dbdf6b1bc2..6f3132682d 100644
--- a/xen/arch/x86/domain.c
+++ b/xen/arch/x86/domain.c
@@ -1781,7 +1781,6 @@ static void __context_switch(void)
per_cpu(curr_vcpu, cpu) = n;
}
-
void context_switch(struct vcpu *prev, struct vcpu *next)
{
unsigned int cpu = smp_processor_id();
@@ -1857,7 +1856,7 @@ void context_switch(struct vcpu *prev, struct vcpu *next)
}
}
- context_saved(prev);
+ sched_context_switched(prev, next);
_update_runstate_area(next);
/* Must be done with interrupts enabled */
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index aad396ee54..78b47acedf 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -55,6 +55,9 @@ boolean_param("sched_smt_power_savings", sched_smt_power_savings);
int sched_ratelimit_us = SCHED_DEFAULT_RATELIMIT_US;
integer_param("sched_ratelimit_us", sched_ratelimit_us);
+/* Number of vcpus per struct sched_unit. */
+static unsigned int __read_mostly sched_granularity = 1;
+
/* Common lock for free cpus. */
static DEFINE_SPINLOCK(sched_free_cpu_lock);
@@ -520,8 +523,8 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
if ( IS_ERR(domdata) )
return PTR_ERR(domdata);
- /* TODO: fix array size with multiple vcpus per unit. */
- unit_priv = xzalloc_array(void *, d->max_vcpus);
+ unit_priv = xzalloc_array(void *,
+ DIV_ROUND_UP(d->max_vcpus, sched_granularity));
if ( unit_priv == NULL )
{
sched_free_domdata(c->sched, domdata);
@@ -1707,133 +1710,319 @@ void vcpu_set_periodic_timer(struct vcpu *v, s_time_t value)
spin_unlock(&v->periodic_timer_lock);
}
-/*
- * The main function
- * - deschedule the current domain (scheduler independent).
- * - pick a new domain (scheduler dependent).
- */
-static void schedule(void)
+static void sched_switch_units(struct sched_resource *sd,
+ struct sched_unit *next, struct sched_unit *prev,
+ s_time_t now)
{
- struct sched_unit *prev = current->sched_unit, *next = NULL;
- s_time_t now;
- struct scheduler *sched;
- unsigned long *tasklet_work = &this_cpu(tasklet_work_to_do);
- bool tasklet_work_scheduled = false;
- struct sched_resource *sd;
- spinlock_t *lock;
- int cpu = smp_processor_id();
+ sd->curr = next;
- ASSERT_NOT_IN_ATOMIC();
+ TRACE_3D(TRC_SCHED_SWITCH_INFPREV, prev->domain->domain_id, prev->unit_id,
+ now - prev->state_entry_time);
+ TRACE_4D(TRC_SCHED_SWITCH_INFNEXT, next->domain->domain_id, next->unit_id,
+ (next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
+ (now - next->state_entry_time) : 0, prev->next_time);
- SCHED_STAT_CRANK(sched_run);
+ ASSERT(prev->vcpu_list->runstate.state == RUNSTATE_running);
- sd = get_sched_res(cpu);
+ TRACE_4D(TRC_SCHED_SWITCH, prev->domain->domain_id, prev->unit_id,
+ next->domain->domain_id, next->unit_id);
+
+ sched_unit_runstate_change(prev, false, now);
+
+ ASSERT(next->vcpu_list->runstate.state != RUNSTATE_running);
+ sched_unit_runstate_change(next, true, now);
+
+ /*
+ * NB. Don't add any trace records from here until the actual context
+ * switch, else lost_records resume will not work properly.
+ */
+
+ ASSERT(!next->is_running);
+ next->vcpu_list->is_running = 1;
+ next->is_running = 1;
+ next->state_entry_time = now;
+}
+
+static bool sched_tasklet_check_cpu(unsigned int cpu)
+{
+ unsigned long *tasklet_work = &per_cpu(tasklet_work_to_do, cpu);
- /* Update tasklet scheduling status. */
switch ( *tasklet_work )
{
case TASKLET_enqueued:
set_bit(_TASKLET_scheduled, tasklet_work);
/* fallthrough */
case TASKLET_enqueued|TASKLET_scheduled:
- tasklet_work_scheduled = true;
+ return true;
break;
case TASKLET_scheduled:
clear_bit(_TASKLET_scheduled, tasklet_work);
+ /* fallthrough */
case 0:
- /*tasklet_work_scheduled = false;*/
+ /* return false; */
break;
default:
BUG();
}
- lock = pcpu_schedule_lock_irq(cpu);
+ return false;
+}
- now = NOW();
+static bool sched_tasklet_check(unsigned int cpu)
+{
+ bool tasklet_work_scheduled = false;
+ const cpumask_t *mask = get_sched_res(cpu)->cpus;
+ unsigned int cpu_iter;
- stop_timer(&sd->s_timer);
+ for_each_cpu ( cpu_iter, mask )
+ if ( sched_tasklet_check_cpu(cpu_iter) )
+ tasklet_work_scheduled = true;
+
+ return tasklet_work_scheduled;
+}
+
+static struct sched_unit *do_schedule(struct sched_unit *prev, s_time_t now,
+ unsigned int cpu)
+{
+ struct scheduler *sched = per_cpu(scheduler, cpu);
+ struct sched_resource *sd = get_sched_res(cpu);
+ struct sched_unit *next;
/* get policy-specific decision on scheduling... */
- sched = this_cpu(scheduler);
- sched->do_schedule(sched, prev, now, tasklet_work_scheduled);
+ sched->do_schedule(sched, prev, now, sched_tasklet_check(cpu));
next = prev->next_task;
- sd->curr = next;
-
if ( prev->next_time >= 0 ) /* -ve means no limit */
set_timer(&sd->s_timer, now + prev->next_time);
- if ( unlikely(prev == next) )
+ if ( likely(prev != next) )
+ sched_switch_units(sd, next, prev, now);
+
+ return next;
+}
+
+static void context_saved(struct vcpu *prev)
+{
+ struct sched_unit *unit = prev->sched_unit;
+
+ /* Clear running flag /after/ writing context to memory. */
+ smp_wmb();
+
+ prev->is_running = 0;
+ unit->is_running = 0;
+ unit->state_entry_time = NOW();
+
+ /* Check for migration request /after/ clearing running flag. */
+ smp_mb();
+
+ sched_context_saved(vcpu_scheduler(prev), unit);
+
+ sched_unit_migrate_finish(unit);
+}
+
+/*
+ * Rendezvous on end of context switch.
+ * As no lock is protecting this rendezvous function we need to use atomic
+ * access functions on the counter.
+ * The counter will be 0 in case no rendezvous is needed. For the rendezvous
+ * case it is initialised to the number of cpus to rendezvous plus 1. Each
+ * member entering decrements the counter. The last one will decrement it to
+ * 1 and perform the final needed action in that case (call of context_saved()
+ * if vcpu was switched), and then set the counter to zero. The other members
+ * will wait until the counter becomes zero until they proceed.
+ */
+void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
+{
+ struct sched_unit *next = vnext->sched_unit;
+
+ if ( atomic_read(&next->rendezvous_out_cnt) )
+ {
+ int cnt = atomic_dec_return(&next->rendezvous_out_cnt);
+
+ /* Call context_saved() before releasing other waiters. */
+ if ( cnt == 1 )
+ {
+ if ( vprev != vnext )
+ context_saved(vprev);
+ atomic_set(&next->rendezvous_out_cnt, 0);
+ }
+ else
+ while ( atomic_read(&next->rendezvous_out_cnt) )
+ cpu_relax();
+ }
+ else if ( vprev != vnext )
+ context_saved(vprev);
+}
+
+static void sched_context_switch(struct vcpu *vprev, struct vcpu *vnext,
+ s_time_t now)
+{
+ if ( unlikely(vprev == vnext) )
{
- pcpu_schedule_unlock_irq(lock, cpu);
TRACE_4D(TRC_SCHED_SWITCH_INFCONT,
- next->domain->domain_id, next->unit_id,
- now - prev->state_entry_time,
- prev->next_time);
- trace_continue_running(next->vcpu_list);
- return continue_running(prev->vcpu_list);
+ vnext->domain->domain_id, vnext->sched_unit->unit_id,
+ now - vprev->runstate.state_entry_time,
+ vprev->sched_unit->next_time);
+ sched_context_switched(vprev, vnext);
+ trace_continue_running(vnext);
+ return continue_running(vprev);
}
- TRACE_3D(TRC_SCHED_SWITCH_INFPREV,
- prev->domain->domain_id, prev->unit_id,
- now - prev->state_entry_time);
- TRACE_4D(TRC_SCHED_SWITCH_INFNEXT,
- next->domain->domain_id, next->unit_id,
- (next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
- (now - next->state_entry_time) : 0,
- prev->next_time);
+ SCHED_STAT_CRANK(sched_ctx);
- ASSERT(prev->vcpu_list->runstate.state == RUNSTATE_running);
+ stop_timer(&vprev->periodic_timer);
- TRACE_4D(TRC_SCHED_SWITCH,
- prev->domain->domain_id, prev->unit_id,
- next->domain->domain_id, next->unit_id);
+ if ( vnext->sched_unit->migrated )
+ vcpu_move_irqs(vnext);
- sched_unit_runstate_change(prev, false, now);
+ vcpu_periodic_timer_work(vnext);
- ASSERT(next->vcpu_list->runstate.state != RUNSTATE_running);
- sched_unit_runstate_change(next, true, now);
+ context_switch(vprev, vnext);
+}
- /*
- * NB. Don't add any trace records from here until the actual context
- * switch, else lost_records resume will not work properly.
- */
+/*
+ * Rendezvous before taking a scheduling decision.
+ * Called with schedule lock held, so all accesses to the rendezvous counter
+ * can be normal ones (no atomic accesses needed).
+ * The counter is initialized to the number of cpus to rendezvous initially.
+ * Each cpu entering will decrement the counter. In case the counter becomes
+ * zero do_schedule() is called and the rendezvous counter for leaving
+ * context_switch() is set. All other members will wait until the counter is
+ * becoming zero, dropping the schedule lock in between.
+ */
+static struct sched_unit *sched_wait_rendezvous_in(struct sched_unit *prev,
+ spinlock_t **lock, int cpu,
+ s_time_t now)
+{
+ struct sched_unit *next;
- ASSERT(!next->is_running);
- next->vcpu_list->is_running = 1;
- next->is_running = 1;
- next->state_entry_time = now;
+ if ( !--prev->rendezvous_in_cnt )
+ {
+ next = do_schedule(prev, now, cpu);
+ atomic_set(&next->rendezvous_out_cnt, sched_granularity + 1);
+ return next;
+ }
- pcpu_schedule_unlock_irq(lock, cpu);
+ while ( prev->rendezvous_in_cnt )
+ {
+ /*
+ * Coming from idle might need to do tasklet work.
+ * In order to avoid deadlocks we can't do that here, but have to
+ * continue the idle loop.
+ * Undo the rendezvous_in_cnt decrement and schedule another call of
+ * sched_slave().
+ */
+ if ( is_idle_unit(prev) && sched_tasklet_check_cpu(cpu) )
+ {
+ struct vcpu *vprev = current;
- SCHED_STAT_CRANK(sched_ctx);
+ prev->rendezvous_in_cnt++;
+ atomic_set(&prev->rendezvous_out_cnt, 0);
- stop_timer(&prev->vcpu_list->periodic_timer);
+ pcpu_schedule_unlock_irq(*lock, cpu);
- if ( next->migrated )
- vcpu_move_irqs(next->vcpu_list);
+ raise_softirq(SCHED_SLAVE_SOFTIRQ);
+ sched_context_switch(vprev, vprev, now);
+ }
- vcpu_periodic_timer_work(next->vcpu_list);
+ pcpu_schedule_unlock_irq(*lock, cpu);
- context_switch(prev->vcpu_list, next->vcpu_list);
+ cpu_relax();
+
+ *lock = pcpu_schedule_lock_irq(cpu);
+ }
+
+ return prev->next_task;
}
-void context_saved(struct vcpu *prev)
+static void sched_slave(void)
{
- /* Clear running flag /after/ writing context to memory. */
- smp_wmb();
+ struct vcpu *vprev = current;
+ struct sched_unit *prev = vprev->sched_unit, *next;
+ s_time_t now;
+ spinlock_t *lock;
+ unsigned int cpu = smp_processor_id();
- prev->is_running = 0;
- prev->sched_unit->is_running = 0;
- prev->sched_unit->state_entry_time = NOW();
+ ASSERT_NOT_IN_ATOMIC();
- /* Check for migration request /after/ clearing running flag. */
- smp_mb();
+ lock = pcpu_schedule_lock_irq(cpu);
+
+ now = NOW();
- sched_context_saved(vcpu_scheduler(prev), prev->sched_unit);
+ if ( !prev->rendezvous_in_cnt )
+ {
+ pcpu_schedule_unlock_irq(lock, cpu);
+ return;
+ }
+
+ stop_timer(&get_sched_res(cpu)->s_timer);
+
+ next = sched_wait_rendezvous_in(prev, &lock, cpu, now);
+
+ pcpu_schedule_unlock_irq(lock, cpu);
- sched_unit_migrate_finish(prev->sched_unit);
+ sched_context_switch(vprev, next->vcpu_list, now);
+}
+
+/*
+ * The main function
+ * - deschedule the current domain (scheduler independent).
+ * - pick a new domain (scheduler dependent).
+ */
+static void schedule(void)
+{
+ struct vcpu *vnext, *vprev = current;
+ struct sched_unit *prev = vprev->sched_unit, *next = NULL;
+ s_time_t now;
+ struct sched_resource *sd;
+ spinlock_t *lock;
+ int cpu = smp_processor_id();
+
+ ASSERT_NOT_IN_ATOMIC();
+
+ SCHED_STAT_CRANK(sched_run);
+
+ sd = get_sched_res(cpu);
+
+ lock = pcpu_schedule_lock_irq(cpu);
+
+ if ( prev->rendezvous_in_cnt )
+ {
+ /*
+ * We have a race: sched_slave() should be called, so raise a softirq
+ * in order to re-enter schedule() later and call sched_slave() now.
+ */
+ pcpu_schedule_unlock_irq(lock, cpu);
+
+ raise_softirq(SCHEDULE_SOFTIRQ);
+ return sched_slave();
+ }
+
+ now = NOW();
+
+ stop_timer(&sd->s_timer);
+
+ if ( sched_granularity > 1 )
+ {
+ cpumask_t mask;
+
+ prev->rendezvous_in_cnt = sched_granularity;
+ cpumask_andnot(&mask, sd->cpus, cpumask_of(cpu));
+ cpumask_raise_softirq(&mask, SCHED_SLAVE_SOFTIRQ);
+ next = sched_wait_rendezvous_in(prev, &lock, cpu, now);
+ }
+ else
+ {
+ prev->rendezvous_in_cnt = 0;
+ next = do_schedule(prev, now, cpu);
+ atomic_set(&next->rendezvous_out_cnt, 0);
+ }
+
+ pcpu_schedule_unlock_irq(lock, cpu);
+
+ vnext = next->vcpu_list;
+ sched_context_switch(vprev, vnext, now);
}
/* The scheduler timer: force a run through the scheduler */
@@ -1874,6 +2063,7 @@ static int cpu_schedule_up(unsigned int cpu)
if ( sd == NULL )
return -ENOMEM;
sd->master_cpu = cpu;
+ sd->cpus = cpumask_of(cpu);
set_sched_res(cpu, sd);
per_cpu(scheduler, cpu) = &sched_idle_ops;
@@ -1894,6 +2084,8 @@ static int cpu_schedule_up(unsigned int cpu)
if ( idle_vcpu[cpu] == NULL )
return -ENOMEM;
+ idle_vcpu[cpu]->sched_unit->rendezvous_in_cnt = 0;
+
/*
* No need to allocate any scheduler data, as cpus coming online are
* free initially and the idle scheduler doesn't need any data areas
@@ -1994,6 +2186,7 @@ void __init scheduler_init(void)
int i;
open_softirq(SCHEDULE_SOFTIRQ, schedule);
+ open_softirq(SCHED_SLAVE_SOFTIRQ, sched_slave);
for ( i = 0; i < NUM_SCHEDULERS; i++)
{
diff --git a/xen/common/softirq.c b/xen/common/softirq.c
index 83c3c09bd5..2d66193203 100644
--- a/xen/common/softirq.c
+++ b/xen/common/softirq.c
@@ -33,8 +33,8 @@ static void __do_softirq(unsigned long ignore_mask)
for ( ; ; )
{
/*
- * Initialise @cpu on every iteration: SCHEDULE_SOFTIRQ may move
- * us to another processor.
+ * Initialise @cpu on every iteration: SCHEDULE_SOFTIRQ or
+ * SCHED_SLAVE_SOFTIRQ may move us to another processor.
*/
cpu = smp_processor_id();
@@ -55,7 +55,7 @@ void process_pending_softirqs(void)
{
ASSERT(!in_irq() && local_irq_is_enabled());
/* Do not enter scheduler as it can preempt the calling context. */
- __do_softirq(1ul<<SCHEDULE_SOFTIRQ);
+ __do_softirq((1ul << SCHEDULE_SOFTIRQ) | (1ul << SCHED_SLAVE_SOFTIRQ));
}
void do_softirq(void)
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 4e89a1e640..4872570612 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -42,6 +42,7 @@ struct sched_resource {
/* Cpu with lowest id in scheduling resource. */
unsigned int master_cpu;
+ const cpumask_t *cpus; /* cpus covered by this struct */
};
#define curr_on_cpu(c) (get_sched_res(c)->curr)
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index a8164d873c..c0e4dc2dc3 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -292,6 +292,12 @@ struct sched_unit {
/* Next unit to run. */
struct sched_unit *next_task;
s_time_t next_time;
+
+ /* Number of vcpus not yet joined for context switch. */
+ unsigned int rendezvous_in_cnt;
+
+ /* Number of vcpus not yet finished with context switch. */
+ atomic_t rendezvous_out_cnt;
};
#define for_each_sched_unit(d, e) \
@@ -694,10 +700,10 @@ void sync_local_execstate(void);
/*
* Called by the scheduler to switch to another VCPU. This function must
- * call context_saved(@prev) when the local CPU is no longer running in
- * @prev's context, and that context is saved to memory. Alternatively, if
- * implementing lazy context switching, it suffices to ensure that invoking
- * sync_vcpu_execstate() will switch and commit @prev's state.
+ * call sched_context_switched(@prev, @next) when the local CPU is no longer
+ * running in @prev's context, and that context is saved to memory.
+ * Alternatively, if implementing lazy context switching, it suffices to ensure
+ * that invoking sync_vcpu_execstate() will switch and commit @prev's state.
*/
void context_switch(
struct vcpu *prev,
@@ -709,7 +715,7 @@ void context_switch(
* saved to memory. Alternatively, if implementing lazy context switching,
* ensure that invoking sync_vcpu_execstate() will switch and commit @prev.
*/
-void context_saved(struct vcpu *prev);
+void sched_context_switched(struct vcpu *prev, struct vcpu *vnext);
/* Called by the scheduler to continue running the current VCPU. */
void continue_running(
diff --git a/xen/include/xen/softirq.h b/xen/include/xen/softirq.h
index c327c9b6cd..d7273b389b 100644
--- a/xen/include/xen/softirq.h
+++ b/xen/include/xen/softirq.h
@@ -4,6 +4,7 @@
/* Low-latency softirqs come first in the following list. */
enum {
TIMER_SOFTIRQ = 0,
+ SCHED_SLAVE_SOFTIRQ,
SCHEDULE_SOFTIRQ,
NEW_TLBFLUSH_CLOCK_PERIOD_SOFTIRQ,
RCU_SOFTIRQ,
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 29/47] xen/sched: introduce unit_runnable_state()
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (27 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 28/47] xen/sched: add code to sync scheduling of all vcpus of a sched unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-23 15:24 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing Juergen Gross
` (19 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Robert VanVossen, Tim Deegan, Julien Grall, Josh Whitehead,
Meng Xu, Jan Beulich, Dario Faggioli
Today the vcpu runstate of a new scheduled vcpu is always set to
"running" even if at that time vcpu_runnable() is already returning
false due to a race (e.g. with pausing the vcpu).
With core scheduling this can no longer work as not all vcpus of a
schedule unit have to be "running" when being scheduled. So the vcpu's
new runstate has to be selected at the same time as the runnability of
the related schedule unit is probed.
For this purpose introduce a new helper unit_runnable_state() which
will save the new runstate of all tested vcpus in a new field of the
vcpu struct.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
RFC V2:
- new patch
V3:
- add vcpu loop to unit_runnable_state() right now instead of doing
so in next patch (Jan Beulich, Dario Faggioli)
- make new_state unsigned int (Jan Beulich)
---
xen/common/domain.c | 1 +
xen/common/sched_arinc653.c | 2 +-
xen/common/sched_credit.c | 49 ++++++++++++++++++++++++---------------------
xen/common/sched_credit2.c | 7 ++++---
xen/common/sched_null.c | 3 ++-
xen/common/sched_rt.c | 8 +++++++-
xen/common/schedule.c | 2 +-
xen/include/xen/sched-if.h | 23 +++++++++++++++++++++
xen/include/xen/sched.h | 1 +
9 files changed, 66 insertions(+), 30 deletions(-)
diff --git a/xen/common/domain.c b/xen/common/domain.c
index 7a1be85be9..fa4023936b 100644
--- a/xen/common/domain.c
+++ b/xen/common/domain.c
@@ -157,6 +157,7 @@ struct vcpu *vcpu_create(struct domain *d, unsigned int vcpu_id)
if ( is_idle_domain(d) )
{
v->runstate.state = RUNSTATE_running;
+ v->new_state = RUNSTATE_running;
}
else
{
diff --git a/xen/common/sched_arinc653.c b/xen/common/sched_arinc653.c
index 96f3e844d2..1e88da40b1 100644
--- a/xen/common/sched_arinc653.c
+++ b/xen/common/sched_arinc653.c
@@ -557,7 +557,7 @@ a653sched_do_schedule(
if ( !((new_task != NULL)
&& (AUNIT(new_task) != NULL)
&& AUNIT(new_task)->awake
- && unit_runnable(new_task)) )
+ && unit_runnable_state(new_task)) )
new_task = IDLETASK(cpu);
BUG_ON(new_task == NULL);
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index 5802a67784..b25a7d2270 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -1894,7 +1894,7 @@ static void csched_schedule(
if ( !test_bit(CSCHED_FLAG_UNIT_YIELD, &scurr->flags)
&& !tasklet_work_scheduled
&& prv->ratelimit
- && unit_runnable(unit)
+ && unit_runnable_state(unit)
&& !is_idle_unit(unit)
&& runtime < prv->ratelimit )
{
@@ -1939,33 +1939,36 @@ static void csched_schedule(
dec_nr_runnable(sched_cpu);
}
- snext = __runq_elem(runq->next);
-
- /* Tasklet work (which runs in idle UNIT context) overrides all else. */
- if ( tasklet_work_scheduled )
- {
- TRACE_0D(TRC_CSCHED_SCHED_TASKLET);
- snext = CSCHED_UNIT(sched_idle_unit(sched_cpu));
- snext->pri = CSCHED_PRI_TS_BOOST;
- }
-
/*
* Clear YIELD flag before scheduling out
*/
clear_bit(CSCHED_FLAG_UNIT_YIELD, &scurr->flags);
- /*
- * SMP Load balance:
- *
- * If the next highest priority local runnable UNIT has already eaten
- * through its credits, look on other PCPUs to see if we have more
- * urgent work... If not, csched_load_balance() will return snext, but
- * already removed from the runq.
- */
- if ( snext->pri > CSCHED_PRI_TS_OVER )
- __runq_remove(snext);
- else
- snext = csched_load_balance(prv, sched_cpu, snext, &migrated);
+ do {
+ snext = __runq_elem(runq->next);
+
+ /* Tasklet work (which runs in idle UNIT context) overrides all else. */
+ if ( tasklet_work_scheduled )
+ {
+ TRACE_0D(TRC_CSCHED_SCHED_TASKLET);
+ snext = CSCHED_UNIT(sched_idle_unit(sched_cpu));
+ snext->pri = CSCHED_PRI_TS_BOOST;
+ }
+
+ /*
+ * SMP Load balance:
+ *
+ * If the next highest priority local runnable UNIT has already eaten
+ * through its credits, look on other PCPUs to see if we have more
+ * urgent work... If not, csched_load_balance() will return snext, but
+ * already removed from the runq.
+ */
+ if ( snext->pri > CSCHED_PRI_TS_OVER )
+ __runq_remove(snext);
+ else
+ snext = csched_load_balance(prv, sched_cpu, snext, &migrated);
+
+ } while ( !unit_runnable_state(snext->unit) );
/*
* Update idlers mask if necessary. When we're idling, other CPUs
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 414ac8f5b6..708643be7e 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -3289,7 +3289,7 @@ runq_candidate(struct csched2_runqueue_data *rqd,
* In fact, it may be the case that scurr is about to spin, and there's
* no point forcing it to do so until rate limiting expires.
*/
- if ( !yield && prv->ratelimit_us && unit_runnable(scurr->unit) &&
+ if ( !yield && prv->ratelimit_us && unit_runnable_state(scurr->unit) &&
(now - scurr->unit->state_entry_time) < MICROSECS(prv->ratelimit_us) )
{
if ( unlikely(tb_init_done) )
@@ -3343,7 +3343,7 @@ runq_candidate(struct csched2_runqueue_data *rqd,
*
* Of course, we also default to idle also if scurr is not runnable.
*/
- if ( unit_runnable(scurr->unit) && !soft_aff_preempt )
+ if ( unit_runnable_state(scurr->unit) && !soft_aff_preempt )
snext = scurr;
else
snext = csched2_unit(sched_idle_unit(cpu));
@@ -3403,7 +3403,8 @@ runq_candidate(struct csched2_runqueue_data *rqd,
* some budget, then choose it.
*/
if ( (yield || svc->credit > snext->credit) &&
- (!has_cap(svc) || unit_grab_budget(svc)) )
+ (!has_cap(svc) || unit_grab_budget(svc)) &&
+ unit_runnable_state(svc->unit) )
snext = svc;
/* In any case, if we got this far, break. */
diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
index d7deef07b8..34ac018cca 100644
--- a/xen/common/sched_null.c
+++ b/xen/common/sched_null.c
@@ -864,7 +864,8 @@ static void null_schedule(const struct scheduler *ops, struct sched_unit *prev,
cpumask_set_cpu(sched_cpu, &prv->cpus_free);
}
- if ( unlikely(prev->next_task == NULL || !unit_runnable(prev->next_task)) )
+ if ( unlikely(prev->next_task == NULL ||
+ !unit_runnable_state(prev->next_task)) )
prev->next_task = sched_idle_unit(sched_cpu);
NULL_UNIT_CHECK(prev->next_task);
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index 91bc3d56fb..9f4e397334 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -1093,12 +1093,18 @@ rt_schedule(const struct scheduler *ops, struct sched_unit *currunit,
else
{
snext = runq_pick(ops, cpumask_of(sched_cpu));
+
if ( snext == NULL )
snext = rt_unit(sched_idle_unit(sched_cpu));
+ else if ( !unit_runnable_state(snext->unit) )
+ {
+ q_remove(snext);
+ snext = rt_unit(sched_idle_unit(sched_cpu));
+ }
/* if scurr has higher priority and budget, still pick scurr */
if ( !is_idle_unit(currunit) &&
- unit_runnable(currunit) &&
+ unit_runnable_state(currunit) &&
scurr->cur_budget > 0 &&
( is_idle_unit(snext->unit) ||
compare_unit_priority(scurr, snext) > 0 ) )
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 78b47acedf..03bcf796ae 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -269,7 +269,7 @@ static inline void sched_unit_runstate_change(struct sched_unit *unit,
struct vcpu *v = unit->vcpu_list;
if ( running )
- vcpu_runstate_change(v, RUNSTATE_running, new_entry_time);
+ vcpu_runstate_change(v, v->new_state, new_entry_time);
else
vcpu_runstate_change(v,
((v->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 4872570612..25ba6f25c9 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -76,6 +76,29 @@ static inline bool unit_runnable(const struct sched_unit *unit)
return vcpu_runnable(unit->vcpu_list);
}
+static inline bool unit_runnable_state(const struct sched_unit *unit)
+{
+ struct vcpu *v;
+ bool runnable, ret = false;
+
+ if ( is_idle_unit(unit) )
+ return true;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ {
+ runnable = vcpu_runnable(v);
+
+ v->new_state = runnable ? RUNSTATE_running
+ : (v->pause_flags & VPF_blocked)
+ ? RUNSTATE_blocked : RUNSTATE_offline;
+
+ if ( runnable )
+ ret = true;
+ }
+
+ return ret;
+}
+
static inline void sched_set_res(struct sched_unit *unit,
struct sched_resource *res)
{
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index c0e4dc2dc3..5b805eac58 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -174,6 +174,7 @@ struct vcpu
XEN_GUEST_HANDLE(vcpu_runstate_info_compat_t) compat;
} runstate_guest; /* guest address */
#endif
+ unsigned int new_state;
/* Has the FPU been initialised? */
bool fpu_initialised;
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (28 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 29/47] xen/sched: introduce unit_runnable_state() Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-23 15:41 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 31/47] xen/sched: modify cpupool_domain_cpumask() to be an unit mask Juergen Gross
` (18 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Tim Deegan, Julien Grall, Jan Beulich, Dario Faggioli
In several places there is support for multiple vcpus per sched unit
missing. Add that missing support (with the exception of initial
allocation) and missing helpers for that.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
RFC V2:
- fix vcpu_runstate_helper()
V1:
- add special handling for idle unit in unit_runnable() and
unit_runnable_state()
V2:
- handle affinity_broken correctly (Jan Beulich)
V3:
- type for cpu ->unsigned int (Jan Beulich)
---
xen/common/domain.c | 5 +++-
xen/common/schedule.c | 37 +++++++++++++-------------
xen/include/xen/sched-if.h | 65 +++++++++++++++++++++++++++++++++++++++-------
3 files changed, 79 insertions(+), 28 deletions(-)
diff --git a/xen/common/domain.c b/xen/common/domain.c
index fa4023936b..ea6aee3858 100644
--- a/xen/common/domain.c
+++ b/xen/common/domain.c
@@ -1259,7 +1259,10 @@ int vcpu_reset(struct vcpu *v)
v->async_exception_mask = 0;
memset(v->async_exception_state, 0, sizeof(v->async_exception_state));
#endif
- v->affinity_broken = 0;
+ if ( v->affinity_broken & VCPU_AFFINITY_OVERRIDE )
+ vcpu_temporary_affinity(v, NR_CPUS, VCPU_AFFINITY_OVERRIDE);
+ if ( v->affinity_broken & VCPU_AFFINITY_WAIT )
+ vcpu_temporary_affinity(v, NR_CPUS, VCPU_AFFINITY_WAIT);
clear_bit(_VPF_blocked, &v->pause_flags);
clear_bit(_VPF_in_reset, &v->pause_flags);
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 03bcf796ae..a79065c826 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -243,8 +243,9 @@ static inline void vcpu_runstate_change(
s_time_t delta;
struct sched_unit *unit = v->sched_unit;
- ASSERT(v->runstate.state != new_state);
ASSERT(spin_is_locked(get_sched_res(v->processor)->schedule_lock));
+ if ( v->runstate.state == new_state )
+ return;
vcpu_urgent_count_update(v);
@@ -266,15 +267,16 @@ static inline void vcpu_runstate_change(
static inline void sched_unit_runstate_change(struct sched_unit *unit,
bool running, s_time_t new_entry_time)
{
- struct vcpu *v = unit->vcpu_list;
+ struct vcpu *v;
- if ( running )
- vcpu_runstate_change(v, v->new_state, new_entry_time);
- else
- vcpu_runstate_change(v,
- ((v->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
- (vcpu_runnable(v) ? RUNSTATE_runnable : RUNSTATE_offline)),
- new_entry_time);
+ for_each_sched_unit_vcpu ( unit, v )
+ if ( running )
+ vcpu_runstate_change(v, v->new_state, new_entry_time);
+ else
+ vcpu_runstate_change(v,
+ ((v->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
+ (vcpu_runnable(v) ? RUNSTATE_runnable : RUNSTATE_offline)),
+ new_entry_time);
}
void vcpu_runstate_get(struct vcpu *v, struct vcpu_runstate_info *runstate)
@@ -1031,10 +1033,9 @@ int cpu_disable_scheduler(unsigned int cpu)
if ( cpumask_empty(&online_affinity) &&
cpumask_test_cpu(cpu, unit->cpu_hard_affinity) )
{
- /* TODO: multiple vcpus per unit. */
- if ( unit->vcpu_list->affinity_broken )
+ if ( sched_check_affinity_broken(unit) )
{
- /* The vcpu is temporarily pinned, can't move it. */
+ /* The unit is temporarily pinned, can't move it. */
unit_schedule_unlock_irqrestore(lock, flags, unit);
ret = -EADDRINUSE;
break;
@@ -1392,17 +1393,17 @@ int vcpu_temporary_affinity(struct vcpu *v, unsigned int cpu, uint8_t reason)
ret = 0;
v->affinity_broken &= ~reason;
}
- if ( !ret && !v->affinity_broken )
+ if ( !ret && !sched_check_affinity_broken(unit) )
sched_set_affinity(v, unit->cpu_hard_affinity_saved, NULL);
}
else if ( cpu < nr_cpu_ids )
{
if ( (v->affinity_broken & reason) ||
- (v->affinity_broken && v->processor != cpu) )
+ (sched_check_affinity_broken(unit) && v->processor != cpu) )
ret = -EBUSY;
else if ( cpumask_test_cpu(cpu, VCPU2ONLINE(v)) )
{
- if ( !v->affinity_broken )
+ if ( !sched_check_affinity_broken(unit) )
{
cpumask_copy(unit->cpu_hard_affinity_saved,
unit->cpu_hard_affinity);
@@ -1722,14 +1723,14 @@ static void sched_switch_units(struct sched_resource *sd,
(next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
(now - next->state_entry_time) : 0, prev->next_time);
- ASSERT(prev->vcpu_list->runstate.state == RUNSTATE_running);
+ ASSERT(unit_running(prev));
TRACE_4D(TRC_SCHED_SWITCH, prev->domain->domain_id, prev->unit_id,
next->domain->domain_id, next->unit_id);
sched_unit_runstate_change(prev, false, now);
- ASSERT(next->vcpu_list->runstate.state != RUNSTATE_running);
+ ASSERT(!unit_running(next));
sched_unit_runstate_change(next, true, now);
/*
@@ -1851,7 +1852,7 @@ void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
while ( atomic_read(&next->rendezvous_out_cnt) )
cpu_relax();
}
- else if ( vprev != vnext )
+ else if ( vprev != vnext && sched_granularity == 1 )
context_saved(vprev);
}
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 25ba6f25c9..6a4dbac935 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -68,12 +68,32 @@ static inline bool is_idle_unit(const struct sched_unit *unit)
static inline bool is_unit_online(const struct sched_unit *unit)
{
- return is_vcpu_online(unit->vcpu_list);
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ if ( is_vcpu_online(v) )
+ return true;
+
+ return false;
+}
+
+static inline unsigned int unit_running(const struct sched_unit *unit)
+{
+ return unit->runstate_cnt[RUNSTATE_running];
}
static inline bool unit_runnable(const struct sched_unit *unit)
{
- return vcpu_runnable(unit->vcpu_list);
+ struct vcpu *v;
+
+ if ( is_idle_unit(unit) )
+ return true;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ if ( vcpu_runnable(v) )
+ return true;
+
+ return false;
}
static inline bool unit_runnable_state(const struct sched_unit *unit)
@@ -102,7 +122,16 @@ static inline bool unit_runnable_state(const struct sched_unit *unit)
static inline void sched_set_res(struct sched_unit *unit,
struct sched_resource *res)
{
- unit->vcpu_list->processor = res->master_cpu;
+ unsigned int cpu = cpumask_first(res->cpus);
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ {
+ ASSERT(cpu < nr_cpu_ids);
+ v->processor = cpu;
+ cpu = cpumask_next(cpu, res->cpus);
+ }
+
unit->res = res;
}
@@ -114,25 +143,37 @@ static inline unsigned int sched_unit_cpu(const struct sched_unit *unit)
static inline void sched_set_pause_flags(struct sched_unit *unit,
unsigned int bit)
{
- __set_bit(bit, &unit->vcpu_list->pause_flags);
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ __set_bit(bit, &v->pause_flags);
}
static inline void sched_clear_pause_flags(struct sched_unit *unit,
unsigned int bit)
{
- __clear_bit(bit, &unit->vcpu_list->pause_flags);
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ __clear_bit(bit, &v->pause_flags);
}
static inline void sched_set_pause_flags_atomic(struct sched_unit *unit,
unsigned int bit)
{
- set_bit(bit, &unit->vcpu_list->pause_flags);
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ set_bit(bit, &v->pause_flags);
}
static inline void sched_clear_pause_flags_atomic(struct sched_unit *unit,
unsigned int bit)
{
- clear_bit(bit, &unit->vcpu_list->pause_flags);
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ clear_bit(bit, &v->pause_flags);
}
static inline struct sched_unit *sched_idle_unit(unsigned int cpu)
@@ -458,12 +499,18 @@ static inline int sched_adjust_cpupool(const struct scheduler *s,
static inline void sched_unit_pause_nosync(struct sched_unit *unit)
{
- vcpu_pause_nosync(unit->vcpu_list);
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ vcpu_pause_nosync(v);
}
static inline void sched_unit_unpause(struct sched_unit *unit)
{
- vcpu_unpause(unit->vcpu_list);
+ struct vcpu *v;
+
+ for_each_sched_unit_vcpu ( unit, v )
+ vcpu_unpause(v);
}
#define REGISTER_SCHEDULER(x) static const struct scheduler *x##_entry \
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 31/47] xen/sched: modify cpupool_domain_cpumask() to be an unit mask
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (29 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-23 15:44 ` Jan Beulich
2019-09-23 15:50 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 32/47] xen/sched: support allocating multiple vcpus into one sched unit Juergen Gross
` (17 subsequent siblings)
48 siblings, 2 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
cpupool_domain_cpumask() is used by scheduling to select cpus or to
iterate over cpus. In order to support scheduling units spanning
multiple cpus let cpupool_domain_cpumask() return a cpumask with only
one bit set per scheduling resource.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/cpupool.c | 29 ++++++++++++++++++++---------
xen/common/schedule.c | 5 +++--
xen/include/xen/sched-if.h | 5 ++++-
3 files changed, 27 insertions(+), 12 deletions(-)
diff --git a/xen/common/cpupool.c b/xen/common/cpupool.c
index fd30040922..a5f4113915 100644
--- a/xen/common/cpupool.c
+++ b/xen/common/cpupool.c
@@ -36,26 +36,35 @@ static DEFINE_SPINLOCK(cpupool_lock);
DEFINE_PER_CPU(struct cpupool *, cpupool);
+static void free_cpupool_struct(struct cpupool *c)
+{
+ if ( c )
+ {
+ free_cpumask_var(c->res_valid);
+ free_cpumask_var(c->cpu_valid);
+ }
+ xfree(c);
+}
+
static struct cpupool *alloc_cpupool_struct(void)
{
struct cpupool *c = xzalloc(struct cpupool);
- if ( !c || !zalloc_cpumask_var(&c->cpu_valid) )
+ if ( !c )
+ return NULL;
+
+ zalloc_cpumask_var(&c->cpu_valid);
+ zalloc_cpumask_var(&c->res_valid);
+
+ if ( !c->cpu_valid || !c->res_valid )
{
- xfree(c);
+ free_cpupool_struct(c);
c = NULL;
}
return c;
}
-static void free_cpupool_struct(struct cpupool *c)
-{
- if ( c )
- free_cpumask_var(c->cpu_valid);
- xfree(c);
-}
-
/*
* find a cpupool by it's id. to be called with cpupool lock held
* if exact is not specified, the first cpupool with an id larger or equal to
@@ -269,6 +278,7 @@ static int cpupool_assign_cpu_locked(struct cpupool *c, unsigned int cpu)
cpupool_cpu_moving = NULL;
}
cpumask_set_cpu(cpu, c->cpu_valid);
+ cpumask_and(c->res_valid, c->cpu_valid, sched_res_mask);
rcu_read_lock(&domlist_read_lock);
for_each_domain_in_cpupool(d, c)
@@ -361,6 +371,7 @@ static int cpupool_unassign_cpu_start(struct cpupool *c, unsigned int cpu)
atomic_inc(&c->refcnt);
cpupool_cpu_moving = c;
cpumask_clear_cpu(cpu, c->cpu_valid);
+ cpumask_and(c->res_valid, c->cpu_valid, sched_res_mask);
out:
spin_unlock(&cpupool_lock);
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index a79065c826..87660c6978 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -57,6 +57,7 @@ integer_param("sched_ratelimit_us", sched_ratelimit_us);
/* Number of vcpus per struct sched_unit. */
static unsigned int __read_mostly sched_granularity = 1;
+const cpumask_t *sched_res_mask = &cpumask_all;
/* Common lock for free cpus. */
static DEFINE_SPINLOCK(sched_free_cpu_lock);
@@ -414,9 +415,9 @@ static unsigned int sched_select_initial_cpu(const struct vcpu *v)
cpumask_clear(cpus);
for_each_node_mask ( node, d->node_affinity )
cpumask_or(cpus, cpus, &node_to_cpumask(node));
- cpumask_and(cpus, cpus, cpupool_domain_cpumask(d));
+ cpumask_and(cpus, cpus, d->cpupool->cpu_valid);
if ( cpumask_empty(cpus) )
- cpumask_copy(cpus, cpupool_domain_cpumask(d));
+ cpumask_copy(cpus, d->cpupool->cpu_valid);
if ( v->vcpu_id == 0 )
cpu_ret = cpumask_first(cpus);
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 6a4dbac935..84d0658578 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -22,6 +22,8 @@ extern cpumask_t cpupool_free_cpus;
#define SCHED_DEFAULT_RATELIMIT_US 1000
extern int sched_ratelimit_us;
+/* Scheduling resource mask. */
+extern const cpumask_t *sched_res_mask;
/*
* In order to allow a scheduler to remap the lock->cpu mapping,
@@ -521,6 +523,7 @@ struct cpupool
int cpupool_id;
unsigned int n_dom;
cpumask_var_t cpu_valid; /* all cpus assigned to pool */
+ cpumask_var_t res_valid; /* all scheduling resources of pool */
struct cpupool *next;
struct scheduler *sched;
atomic_t refcnt;
@@ -536,7 +539,7 @@ static inline cpumask_t *cpupool_domain_cpumask(const struct domain *d)
* be interested in calling this for the idle domain.
*/
ASSERT(d->cpupool != NULL);
- return d->cpupool->cpu_valid;
+ return d->cpupool->res_valid;
}
/*
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 32/47] xen/sched: support allocating multiple vcpus into one sched unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (30 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 31/47] xen/sched: modify cpupool_domain_cpumask() to be an unit mask Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 9:46 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 33/47] xen/sched: add a percpu resource index Juergen Gross
` (16 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Dario Faggioli
With a scheduling granularity greater than 1 multiple vcpus share the
same struct sched_unit. Support that.
Setting the initial processor must be done carefully: we can't use
sched_set_res() as that relies on for_each_sched_unit_vcpu() which in
turn needs the vcpu already as a member of the domain's vcpu linked
list, which isn't the case.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/schedule.c | 86 ++++++++++++++++++++++++++++++++++++++-------------
1 file changed, 65 insertions(+), 21 deletions(-)
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 87660c6978..5e34008ca8 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -338,10 +338,26 @@ static void sched_spin_unlock_double(spinlock_t *lock1, spinlock_t *lock2,
spin_unlock_irqrestore(lock1, flags);
}
-static void sched_free_unit(struct sched_unit *unit)
+static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
{
struct sched_unit *prev_unit;
struct domain *d = unit->domain;
+ struct vcpu *vunit;
+ unsigned int cnt = 0;
+
+ /* Don't count to be released vcpu, might be not in vcpu list yet. */
+ for_each_sched_unit_vcpu ( unit, vunit )
+ if ( vunit != v )
+ cnt++;
+
+ v->sched_unit = NULL;
+ unit->runstate_cnt[v->runstate.state]--;
+
+ if ( cnt )
+ return;
+
+ if ( unit->vcpu_list == v )
+ unit->vcpu_list = v->next_in_list;
if ( d->sched_unit_list == unit )
d->sched_unit_list = unit->next_in_list;
@@ -357,8 +373,6 @@ static void sched_free_unit(struct sched_unit *unit)
}
}
- unit->vcpu_list->sched_unit = NULL;
-
free_cpumask_var(unit->cpu_hard_affinity);
free_cpumask_var(unit->cpu_hard_affinity_saved);
free_cpumask_var(unit->cpu_soft_affinity);
@@ -366,18 +380,38 @@ static void sched_free_unit(struct sched_unit *unit)
xfree(unit);
}
+static void sched_unit_add_vcpu(struct sched_unit *unit, struct vcpu *v)
+{
+ v->sched_unit = unit;
+ if ( !unit->vcpu_list || unit->vcpu_list->vcpu_id > v->vcpu_id )
+ {
+ unit->vcpu_list = v;
+ unit->unit_id = v->vcpu_id;
+ }
+ unit->runstate_cnt[v->runstate.state]++;
+}
+
static struct sched_unit *sched_alloc_unit(struct vcpu *v)
{
struct sched_unit *unit, **prev_unit;
struct domain *d = v->domain;
+ for_each_sched_unit ( d, unit )
+ if ( unit->vcpu_list->vcpu_id / sched_granularity ==
+ v->vcpu_id / sched_granularity )
+ break;
+
+ if ( unit )
+ {
+ sched_unit_add_vcpu(unit, v);
+ return unit;
+ }
+
if ( (unit = xzalloc(struct sched_unit)) == NULL )
return NULL;
- unit->vcpu_list = v;
- unit->unit_id = v->vcpu_id;
unit->domain = d;
- unit->runstate_cnt[v->runstate.state]++;
+ sched_unit_add_vcpu(unit, v);
for ( prev_unit = &d->sched_unit_list; *prev_unit;
prev_unit = &(*prev_unit)->next_in_list )
@@ -393,12 +427,10 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
!zalloc_cpumask_var(&unit->cpu_soft_affinity) )
goto fail;
- v->sched_unit = unit;
-
return unit;
fail:
- sched_free_unit(unit);
+ sched_free_unit(unit, v);
return NULL;
}
@@ -448,21 +480,26 @@ int sched_init_vcpu(struct vcpu *v)
else
processor = sched_select_initial_cpu(v);
- sched_set_res(unit, get_sched_res(processor));
-
/* Initialise the per-vcpu timers. */
spin_lock_init(&v->periodic_timer_lock);
- init_timer(&v->periodic_timer, vcpu_periodic_timer_fn,
- v, v->processor);
- init_timer(&v->singleshot_timer, vcpu_singleshot_timer_fn,
- v, v->processor);
- init_timer(&v->poll_timer, poll_timer_fn,
- v, v->processor);
+ init_timer(&v->periodic_timer, vcpu_periodic_timer_fn, v, processor);
+ init_timer(&v->singleshot_timer, vcpu_singleshot_timer_fn, v, processor);
+ init_timer(&v->poll_timer, poll_timer_fn, v, processor);
+
+ /* If this is not the first vcpu of the unit we are done. */
+ if ( unit->priv != NULL )
+ {
+ v->processor = processor;
+ return 0;
+ }
+
+ /* The first vcpu of an unit can be set via sched_set_res(). */
+ sched_set_res(unit, get_sched_res(processor));
unit->priv = sched_alloc_vdata(dom_scheduler(d), unit, d->sched_priv);
if ( unit->priv == NULL )
{
- sched_free_unit(unit);
+ sched_free_unit(unit, v);
return 1;
}
@@ -622,9 +659,16 @@ void sched_destroy_vcpu(struct vcpu *v)
kill_timer(&v->poll_timer);
if ( test_and_clear_bool(v->is_urgent) )
atomic_dec(&per_cpu(sched_urgent_count, v->processor));
- sched_remove_unit(vcpu_scheduler(v), unit);
- sched_free_vdata(vcpu_scheduler(v), unit->priv);
- sched_free_unit(unit);
+ /*
+ * Vcpus are being destroyed top-down. So being the first vcpu of an unit
+ * is the same as being the only one.
+ */
+ if ( unit->vcpu_list == v )
+ {
+ sched_remove_unit(vcpu_scheduler(v), unit);
+ sched_free_vdata(vcpu_scheduler(v), unit->priv);
+ sched_free_unit(unit, v);
+ }
}
int sched_init_domain(struct domain *d, int poolid)
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 33/47] xen/sched: add a percpu resource index
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (31 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 32/47] xen/sched: support allocating multiple vcpus into one sched unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 10:05 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 34/47] xen/sched: add fall back to idle vcpu when scheduling unit Juergen Gross
` (15 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Dario Faggioli
Add a percpu variable holding the index of the cpu in the current
sched_resource structure. This index is used to get the correct vcpu
of a sched_unit on a specific cpu.
For now this index will be zero for all cpus, but with core scheduling
it will be possible to have higher values, too.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
RFC V2: new patch (carved out from RFC V1 patch 49)
---
xen/common/schedule.c | 11 +++++++++--
1 file changed, 9 insertions(+), 2 deletions(-)
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 5e34008ca8..246ad38c7d 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -71,6 +71,7 @@ static void poll_timer_fn(void *data);
/* This is global for now so that private implementations can reach it */
DEFINE_PER_CPU(struct scheduler *, scheduler);
DEFINE_PER_CPU_READ_MOSTLY(struct sched_resource *, sched_res);
+static DEFINE_PER_CPU_READ_MOSTLY(unsigned int, sched_res_idx);
/* Scratch space for cpumasks. */
DEFINE_PER_CPU(cpumask_t, cpumask_scratch);
@@ -135,6 +136,12 @@ static struct scheduler sched_idle_ops = {
.switch_sched = sched_idle_switch_sched,
};
+static inline struct vcpu *sched_unit2vcpu_cpu(struct sched_unit *unit,
+ unsigned int cpu)
+{
+ return unit->domain->vcpu[unit->unit_id + per_cpu(sched_res_idx, cpu)];
+}
+
static inline struct scheduler *dom_scheduler(const struct domain *d)
{
if ( likely(d->cpupool != NULL) )
@@ -2008,7 +2015,7 @@ static void sched_slave(void)
pcpu_schedule_unlock_irq(lock, cpu);
- sched_context_switch(vprev, next->vcpu_list, now);
+ sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu), now);
}
/*
@@ -2067,7 +2074,7 @@ static void schedule(void)
pcpu_schedule_unlock_irq(lock, cpu);
- vnext = next->vcpu_list;
+ vnext = sched_unit2vcpu_cpu(next, cpu);
sched_context_switch(vprev, vnext, now);
}
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 34/47] xen/sched: add fall back to idle vcpu when scheduling unit
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (32 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 33/47] xen/sched: add a percpu resource index Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 10:53 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 35/47] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware Juergen Gross
` (14 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Tim Deegan, Julien Grall, Jan Beulich, Dario Faggioli,
Volodymyr Babchuk, Roger Pau Monné
When scheduling an unit with multiple vcpus there is no guarantee all
vcpus are available (e.g. above maxvcpus or vcpu offline). Fall back to
idle vcpu of the current cpu in that case. This requires to store the
correct schedule_unit pointer in the idle vcpu as long as it used as
fallback vcpu.
In order to modify the runstates of the correct vcpus when switching
schedule units merge sched_unit_runstate_change() into
sched_switch_units() and loop over the affected physical cpus instead
of the unit's vcpus. This in turn requires an access function to the
current variable of other cpus.
Today context_saved() is called in case previous and next vcpus differ
when doing a context switch. With an idle vcpu being capable to be a
substitute for an offline vcpu this is problematic when switching to
an idle scheduling unit. An idle previous vcpu leaves us in doubt which
schedule unit was active previously, so save the previous unit pointer
in the per-schedule resource area. If it is NULL the unit has not
changed and we don't have to set the previous unit to be not running.
When running an idle vcpu in a non-idle scheduling unit use a specific
guest idle loop not performing any tasklets and livepatching in order
to avoid populating the cpu caches with memory used by other domains
(as far as possible). Softirqs are considered to be save.
In order to avoid livepatching when going to guest idle another
variant of reset_stack_and_jump() not calling check_for_livepatch_work
is needed.
Signed-off-by: Juergen Gross <jgross@suse.com>
Acked-by: Julien Grall <julien.grall@arm.com>
---
RFC V2:
- new patch (Andrew Cooper)
V1:
- use urgent_count to select correct idle routine (Jan Beulich)
V2:
- set vcpu->is_running in context_saved()
- introduce reset_stack_and_jump_nolp() (Jan Beulich)
- readd scrubbing (Jan Beulich, Andrew Cooper)
- get_cpu_current() _NOT_ moved to include/asm-x86/current.h as the
needed reference of stack_base[] results in a #include hell
V3:
- split context_saved() into unit_context_saved() and vcpu_context_saved()
---
xen/arch/x86/domain.c | 23 ++++++
xen/common/schedule.c | 180 +++++++++++++++++++++++++++++-------------
xen/include/asm-arm/current.h | 1 +
xen/include/asm-x86/current.h | 19 ++++-
xen/include/asm-x86/smp.h | 3 +
xen/include/xen/sched-if.h | 4 +-
xen/include/xen/sched.h | 1 +
7 files changed, 170 insertions(+), 61 deletions(-)
diff --git a/xen/arch/x86/domain.c b/xen/arch/x86/domain.c
index 6f3132682d..8d430d38c2 100644
--- a/xen/arch/x86/domain.c
+++ b/xen/arch/x86/domain.c
@@ -159,6 +159,25 @@ static void idle_loop(void)
}
}
+/*
+ * Idle loop for siblings in active schedule units.
+ * We don't do any standard idle work like tasklets or livepatching.
+ */
+static void guest_idle_loop(void)
+{
+ unsigned int cpu = smp_processor_id();
+
+ for ( ; ; )
+ {
+ ASSERT(!cpu_is_offline(cpu));
+
+ if ( !softirq_pending(cpu) && !scrub_free_pages() &&
+ !softirq_pending(cpu))
+ sched_guest_idle(pm_idle, cpu);
+ do_softirq();
+ }
+}
+
void startup_cpu_idle_loop(void)
{
struct vcpu *v = current;
@@ -172,6 +191,10 @@ void startup_cpu_idle_loop(void)
static void noreturn continue_idle_domain(struct vcpu *v)
{
+ /* Idle vcpus might be attached to non-idle units! */
+ if ( !is_idle_domain(v->sched_unit->domain) )
+ reset_stack_and_jump_nolp(guest_idle_loop);
+
reset_stack_and_jump(idle_loop);
}
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 246ad38c7d..d53c60b966 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -136,10 +136,21 @@ static struct scheduler sched_idle_ops = {
.switch_sched = sched_idle_switch_sched,
};
+static inline struct vcpu *unit2vcpu_cpu(struct sched_unit *unit,
+ unsigned int cpu)
+{
+ unsigned int idx = unit->unit_id + per_cpu(sched_res_idx, cpu);
+ const struct domain *d = unit->domain;
+
+ return (idx < d->max_vcpus) ? d->vcpu[idx] : NULL;
+}
+
static inline struct vcpu *sched_unit2vcpu_cpu(struct sched_unit *unit,
unsigned int cpu)
{
- return unit->domain->vcpu[unit->unit_id + per_cpu(sched_res_idx, cpu)];
+ struct vcpu *v = unit2vcpu_cpu(unit, cpu);
+
+ return (v && v->new_state == RUNSTATE_running) ? v : idle_vcpu[cpu];
}
static inline struct scheduler *dom_scheduler(const struct domain *d)
@@ -259,8 +270,11 @@ static inline void vcpu_runstate_change(
trace_runstate_change(v, new_state);
- unit->runstate_cnt[v->runstate.state]--;
- unit->runstate_cnt[new_state]++;
+ if ( !is_idle_vcpu(v) )
+ {
+ unit->runstate_cnt[v->runstate.state]--;
+ unit->runstate_cnt[new_state]++;
+ }
delta = new_entry_time - v->runstate.state_entry_time;
if ( delta > 0 )
@@ -272,19 +286,11 @@ static inline void vcpu_runstate_change(
v->runstate.state = new_state;
}
-static inline void sched_unit_runstate_change(struct sched_unit *unit,
- bool running, s_time_t new_entry_time)
+void sched_guest_idle(void (*idle) (void), unsigned int cpu)
{
- struct vcpu *v;
-
- for_each_sched_unit_vcpu ( unit, v )
- if ( running )
- vcpu_runstate_change(v, v->new_state, new_entry_time);
- else
- vcpu_runstate_change(v,
- ((v->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
- (vcpu_runnable(v) ? RUNSTATE_runnable : RUNSTATE_offline)),
- new_entry_time);
+ atomic_inc(&per_cpu(sched_urgent_count, cpu));
+ idle();
+ atomic_dec(&per_cpu(sched_urgent_count, cpu));
}
void vcpu_runstate_get(struct vcpu *v, struct vcpu_runstate_info *runstate)
@@ -523,6 +529,7 @@ int sched_init_vcpu(struct vcpu *v)
if ( is_idle_domain(d) )
{
get_sched_res(v->processor)->curr = unit;
+ get_sched_res(v->processor)->sched_unit_idle = unit;
v->is_running = 1;
unit->is_running = 1;
unit->state_entry_time = NOW();
@@ -855,7 +862,7 @@ static void sched_unit_move_locked(struct sched_unit *unit,
*
* sched_unit_migrate_finish() will do the work now if it can, or simply
* return if it can't (because unit is still running); in that case
- * sched_unit_migrate_finish() will be called by context_saved().
+ * sched_unit_migrate_finish() will be called by unit_context_saved().
*/
static void sched_unit_migrate_start(struct sched_unit *unit)
{
@@ -878,7 +885,7 @@ static void sched_unit_migrate_finish(struct sched_unit *unit)
/*
* If the unit is currently running, this will be handled by
- * context_saved(); and in any case, if the bit is cleared, then
+ * unit_context_saved(); and in any case, if the bit is cleared, then
* someone else has already done the work so we don't need to.
*/
if ( unit->is_running )
@@ -1767,33 +1774,66 @@ static void sched_switch_units(struct sched_resource *sd,
struct sched_unit *next, struct sched_unit *prev,
s_time_t now)
{
- sd->curr = next;
-
- TRACE_3D(TRC_SCHED_SWITCH_INFPREV, prev->domain->domain_id, prev->unit_id,
- now - prev->state_entry_time);
- TRACE_4D(TRC_SCHED_SWITCH_INFNEXT, next->domain->domain_id, next->unit_id,
- (next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
- (now - next->state_entry_time) : 0, prev->next_time);
+ int cpu;
ASSERT(unit_running(prev));
- TRACE_4D(TRC_SCHED_SWITCH, prev->domain->domain_id, prev->unit_id,
- next->domain->domain_id, next->unit_id);
+ if ( prev != next )
+ {
+ sd->curr = next;
+ sd->prev = prev;
- sched_unit_runstate_change(prev, false, now);
+ TRACE_3D(TRC_SCHED_SWITCH_INFPREV, prev->domain->domain_id,
+ prev->unit_id, now - prev->state_entry_time);
+ TRACE_4D(TRC_SCHED_SWITCH_INFNEXT, next->domain->domain_id,
+ next->unit_id,
+ (next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
+ (now - next->state_entry_time) : 0, prev->next_time);
+ TRACE_4D(TRC_SCHED_SWITCH, prev->domain->domain_id, prev->unit_id,
+ next->domain->domain_id, next->unit_id);
- ASSERT(!unit_running(next));
- sched_unit_runstate_change(next, true, now);
+ ASSERT(!unit_running(next));
- /*
- * NB. Don't add any trace records from here until the actual context
- * switch, else lost_records resume will not work properly.
- */
+ /*
+ * NB. Don't add any trace records from here until the actual context
+ * switch, else lost_records resume will not work properly.
+ */
+
+ ASSERT(!next->is_running);
+ next->is_running = 1;
+ next->state_entry_time = now;
+
+ if ( is_idle_unit(prev) )
+ {
+ prev->runstate_cnt[RUNSTATE_running] = 0;
+ prev->runstate_cnt[RUNSTATE_runnable] = sched_granularity;
+ }
+ if ( is_idle_unit(next) )
+ {
+ next->runstate_cnt[RUNSTATE_running] = sched_granularity;
+ next->runstate_cnt[RUNSTATE_runnable] = 0;
+ }
+ }
+
+ for_each_cpu ( cpu, sd->cpus )
+ {
+ struct vcpu *vprev = get_cpu_current(cpu);
+ struct vcpu *vnext = sched_unit2vcpu_cpu(next, cpu);
+
+ if ( vprev != vnext || vprev->runstate.state != vnext->new_state )
+ {
+ vcpu_runstate_change(vprev,
+ ((vprev->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
+ (vcpu_runnable(vprev) ? RUNSTATE_runnable : RUNSTATE_offline)),
+ now);
+ vcpu_runstate_change(vnext, vnext->new_state, now);
+ }
- ASSERT(!next->is_running);
- next->vcpu_list->is_running = 1;
- next->is_running = 1;
- next->state_entry_time = now;
+ vnext->is_running = 1;
+
+ if ( is_idle_vcpu(vnext) )
+ vnext->sched_unit = next;
+ }
}
static bool sched_tasklet_check_cpu(unsigned int cpu)
@@ -1849,29 +1889,39 @@ static struct sched_unit *do_schedule(struct sched_unit *prev, s_time_t now,
if ( prev->next_time >= 0 ) /* -ve means no limit */
set_timer(&sd->s_timer, now + prev->next_time);
- if ( likely(prev != next) )
- sched_switch_units(sd, next, prev, now);
+ sched_switch_units(sd, next, prev, now);
return next;
}
-static void context_saved(struct vcpu *prev)
+static void vcpu_context_saved(struct vcpu *vprev, struct vcpu *vnext)
{
- struct sched_unit *unit = prev->sched_unit;
-
/* Clear running flag /after/ writing context to memory. */
smp_wmb();
- prev->is_running = 0;
+ if ( vprev != vnext )
+ vprev->is_running = 0;
+}
+
+static void unit_context_saved(struct sched_resource *sd)
+{
+ struct sched_unit *unit = sd->prev;
+
+ if ( !unit )
+ return;
+
unit->is_running = 0;
unit->state_entry_time = NOW();
+ sd->prev = NULL;
/* Check for migration request /after/ clearing running flag. */
smp_mb();
- sched_context_saved(vcpu_scheduler(prev), unit);
+ sched_context_saved(unit_scheduler(unit), unit);
- sched_unit_migrate_finish(unit);
+ /* Idle never migrates and idle vcpus might belong to other units. */
+ if ( !is_idle_unit(unit) )
+ sched_unit_migrate_finish(unit);
}
/*
@@ -1881,35 +1931,44 @@ static void context_saved(struct vcpu *prev)
* The counter will be 0 in case no rendezvous is needed. For the rendezvous
* case it is initialised to the number of cpus to rendezvous plus 1. Each
* member entering decrements the counter. The last one will decrement it to
- * 1 and perform the final needed action in that case (call of context_saved()
- * if vcpu was switched), and then set the counter to zero. The other members
+ * 1 and perform the final needed action in that case (call of
+ * unit_context_saved()), and then set the counter to zero. The other members
* will wait until the counter becomes zero until they proceed.
*/
void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
{
struct sched_unit *next = vnext->sched_unit;
+ struct sched_resource *sd = get_sched_res(smp_processor_id());
if ( atomic_read(&next->rendezvous_out_cnt) )
{
int cnt = atomic_dec_return(&next->rendezvous_out_cnt);
- /* Call context_saved() before releasing other waiters. */
+ vcpu_context_saved(vprev, vnext);
+
+ /* Call unit_context_saved() before releasing other waiters. */
if ( cnt == 1 )
{
- if ( vprev != vnext )
- context_saved(vprev);
+ unit_context_saved(sd);
atomic_set(&next->rendezvous_out_cnt, 0);
}
else
while ( atomic_read(&next->rendezvous_out_cnt) )
cpu_relax();
}
- else if ( vprev != vnext && sched_granularity == 1 )
- context_saved(vprev);
+ else
+ {
+ vcpu_context_saved(vprev, vnext);
+ if ( sched_granularity == 1 )
+ unit_context_saved(sd);
+ }
+
+ if ( is_idle_vcpu(vprev) && vprev != vnext )
+ vprev->sched_unit = sd->sched_unit_idle;
}
static void sched_context_switch(struct vcpu *vprev, struct vcpu *vnext,
- s_time_t now)
+ bool reset_idle_unit, s_time_t now)
{
if ( unlikely(vprev == vnext) )
{
@@ -1918,6 +1977,11 @@ static void sched_context_switch(struct vcpu *vprev, struct vcpu *vnext,
now - vprev->runstate.state_entry_time,
vprev->sched_unit->next_time);
sched_context_switched(vprev, vnext);
+
+ if ( reset_idle_unit )
+ vnext->sched_unit =
+ get_sched_res(smp_processor_id())->sched_unit_idle;
+
trace_continue_running(vnext);
return continue_running(vprev);
}
@@ -1976,7 +2040,7 @@ static struct sched_unit *sched_wait_rendezvous_in(struct sched_unit *prev,
pcpu_schedule_unlock_irq(*lock, cpu);
raise_softirq(SCHED_SLAVE_SOFTIRQ);
- sched_context_switch(vprev, vprev, now);
+ sched_context_switch(vprev, vprev, false, now);
}
pcpu_schedule_unlock_irq(*lock, cpu);
@@ -2015,7 +2079,8 @@ static void sched_slave(void)
pcpu_schedule_unlock_irq(lock, cpu);
- sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu), now);
+ sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu),
+ is_idle_unit(next) && !is_idle_unit(prev), now);
}
/*
@@ -2075,7 +2140,8 @@ static void schedule(void)
pcpu_schedule_unlock_irq(lock, cpu);
vnext = sched_unit2vcpu_cpu(next, cpu);
- sched_context_switch(vprev, vnext, now);
+ sched_context_switch(vprev, vnext,
+ !is_idle_unit(prev) && is_idle_unit(next), now);
}
/* The scheduler timer: force a run through the scheduler */
@@ -2146,6 +2212,7 @@ static int cpu_schedule_up(unsigned int cpu)
*/
sd->curr = idle_vcpu[cpu]->sched_unit;
+ sd->sched_unit_idle = idle_vcpu[cpu]->sched_unit;
sd->sched_priv = NULL;
@@ -2315,6 +2382,7 @@ void __init scheduler_init(void)
if ( vcpu_create(idle_domain, 0) == NULL )
BUG();
get_sched_res(0)->curr = idle_vcpu[0]->sched_unit;
+ get_sched_res(0)->sched_unit_idle = idle_vcpu[0]->sched_unit;
}
/*
diff --git a/xen/include/asm-arm/current.h b/xen/include/asm-arm/current.h
index 1653e89d30..88beb4645a 100644
--- a/xen/include/asm-arm/current.h
+++ b/xen/include/asm-arm/current.h
@@ -18,6 +18,7 @@ DECLARE_PER_CPU(struct vcpu *, curr_vcpu);
#define current (this_cpu(curr_vcpu))
#define set_current(vcpu) do { current = (vcpu); } while (0)
+#define get_cpu_current(cpu) (per_cpu(curr_vcpu, cpu))
/* Per-VCPU state that lives at the top of the stack */
struct cpu_info {
diff --git a/xen/include/asm-x86/current.h b/xen/include/asm-x86/current.h
index f3508c3c08..0b47485337 100644
--- a/xen/include/asm-x86/current.h
+++ b/xen/include/asm-x86/current.h
@@ -77,6 +77,11 @@ struct cpu_info {
/* get_stack_bottom() must be 16-byte aligned */
};
+static inline struct cpu_info *get_cpu_info_from_stack(unsigned long sp)
+{
+ return (struct cpu_info *)((sp | (STACK_SIZE - 1)) + 1) - 1;
+}
+
static inline struct cpu_info *get_cpu_info(void)
{
#ifdef __clang__
@@ -87,7 +92,7 @@ static inline struct cpu_info *get_cpu_info(void)
register unsigned long sp asm("rsp");
#endif
- return (struct cpu_info *)((sp | (STACK_SIZE - 1)) + 1) - 1;
+ return get_cpu_info_from_stack(sp);
}
#define get_current() (get_cpu_info()->current_vcpu)
@@ -124,16 +129,22 @@ unsigned long get_stack_dump_bottom (unsigned long sp);
# define CHECK_FOR_LIVEPATCH_WORK ""
#endif
-#define reset_stack_and_jump(__fn) \
+#define switch_stack_and_jump(fn, instr) \
({ \
__asm__ __volatile__ ( \
"mov %0,%%"__OP"sp;" \
- CHECK_FOR_LIVEPATCH_WORK \
+ instr \
"jmp %c1" \
- : : "r" (guest_cpu_user_regs()), "i" (__fn) : "memory" ); \
+ : : "r" (guest_cpu_user_regs()), "i" (fn) : "memory" ); \
unreachable(); \
})
+#define reset_stack_and_jump(fn) \
+ switch_stack_and_jump(fn, CHECK_FOR_LIVEPATCH_WORK)
+
+#define reset_stack_and_jump_nolp(fn) \
+ switch_stack_and_jump(fn, "")
+
/*
* Which VCPU's state is currently running on each CPU?
* This is not necesasrily the same as 'current' as a CPU may be
diff --git a/xen/include/asm-x86/smp.h b/xen/include/asm-x86/smp.h
index 9f533f9072..51a31ab00a 100644
--- a/xen/include/asm-x86/smp.h
+++ b/xen/include/asm-x86/smp.h
@@ -76,6 +76,9 @@ void set_nr_sockets(void);
/* Representing HT and core siblings in each socket. */
extern cpumask_t **socket_cpumask;
+#define get_cpu_current(cpu) \
+ (get_cpu_info_from_stack((unsigned long)stack_base[cpu])->current_vcpu)
+
#endif /* !__ASSEMBLY__ */
#endif
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 84d0658578..2929154d35 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -39,6 +39,8 @@ struct sched_resource {
spinlock_t *schedule_lock,
_lock;
struct sched_unit *curr;
+ struct sched_unit *sched_unit_idle;
+ struct sched_unit *prev;
void *sched_priv;
struct timer s_timer; /* scheduling timer */
@@ -180,7 +182,7 @@ static inline void sched_clear_pause_flags_atomic(struct sched_unit *unit,
static inline struct sched_unit *sched_idle_unit(unsigned int cpu)
{
- return idle_vcpu[cpu]->sched_unit;
+ return get_sched_res(cpu)->sched_unit_idle;
}
static inline unsigned int sched_get_resource_cpu(unsigned int cpu)
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 5b805eac58..144d353447 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -929,6 +929,7 @@ void restore_vcpu_affinity(struct domain *d);
void vcpu_runstate_get(struct vcpu *v, struct vcpu_runstate_info *runstate);
uint64_t get_cpu_idle_time(unsigned int cpu);
+void sched_guest_idle(void (*idle) (void), unsigned int cpu);
/*
* Used by idle loop to decide whether there is work to do:
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 35/47] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (33 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 34/47] xen/sched: add fall back to idle vcpu when scheduling unit Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 11:55 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 36/47] xen/sched: carve out freeing sched_unit memory into dedicated function Juergen Gross
` (13 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
vcpu_wake() and vcpu_sleep() need to be made core scheduling aware:
they might need to switch a single vcpu of an already scheduled unit
between running and not running.
Especially when vcpu_sleep() for a vcpu is being called by a vcpu of
the same scheduling unit special care must be taken in order to avoid
a deadlock: the vcpu to be put asleep must be forced through a
context switch without doing so for the calling vcpu. For this
purpose add a vcpu flag handled in sched_slave() and in
sched_wait_rendezvous_in() allowing a vcpu of the currently running
unit to switch state at a higher priority than a normal schedule
event.
Use the same mechanism when waking up a vcpu of a currently active
unit.
While at it make vcpu_sleep_nosync_locked() static as it is used in
schedule.c only.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
RFC V2: add vcpu_sleep() handling and force_context_switch flag
V2: fix runstate change in sched_force_context_switch()
---
xen/common/schedule.c | 125 ++++++++++++++++++++++++++++++++++++++++++---
xen/include/xen/sched-if.h | 9 ++--
xen/include/xen/sched.h | 2 +
3 files changed, 127 insertions(+), 9 deletions(-)
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index d53c60b966..1e793617ec 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -724,8 +724,10 @@ void sched_destroy_domain(struct domain *d)
}
}
-void vcpu_sleep_nosync_locked(struct vcpu *v)
+static void vcpu_sleep_nosync_locked(struct vcpu *v)
{
+ struct sched_unit *unit = v->sched_unit;
+
ASSERT(spin_is_locked(get_sched_res(v->processor)->schedule_lock));
if ( likely(!vcpu_runnable(v)) )
@@ -733,7 +735,14 @@ void vcpu_sleep_nosync_locked(struct vcpu *v)
if ( v->runstate.state == RUNSTATE_runnable )
vcpu_runstate_change(v, RUNSTATE_offline, NOW());
- sched_sleep(vcpu_scheduler(v), v->sched_unit);
+ if ( likely(!unit_runnable(unit)) )
+ sched_sleep(vcpu_scheduler(v), unit);
+ else if ( unit_running(unit) > 1 && v->is_running &&
+ !v->force_context_switch )
+ {
+ v->force_context_switch = true;
+ cpu_raise_softirq(v->processor, SCHED_SLAVE_SOFTIRQ);
+ }
}
}
@@ -765,16 +774,22 @@ void vcpu_wake(struct vcpu *v)
{
unsigned long flags;
spinlock_t *lock;
+ struct sched_unit *unit = v->sched_unit;
TRACE_2D(TRC_SCHED_WAKE, v->domain->domain_id, v->vcpu_id);
- lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
+ lock = unit_schedule_lock_irqsave(unit, &flags);
if ( likely(vcpu_runnable(v)) )
{
if ( v->runstate.state >= RUNSTATE_blocked )
vcpu_runstate_change(v, RUNSTATE_runnable, NOW());
- sched_wake(vcpu_scheduler(v), v->sched_unit);
+ sched_wake(vcpu_scheduler(v), unit);
+ if ( unit->is_running && !v->is_running && !v->force_context_switch )
+ {
+ v->force_context_switch = true;
+ cpu_raise_softirq(v->processor, SCHED_SLAVE_SOFTIRQ);
+ }
}
else if ( !(v->pause_flags & VPF_blocked) )
{
@@ -782,7 +797,7 @@ void vcpu_wake(struct vcpu *v)
vcpu_runstate_change(v, RUNSTATE_offline, NOW());
}
- unit_schedule_unlock_irqrestore(lock, flags, v->sched_unit);
+ unit_schedule_unlock_irqrestore(lock, flags, unit);
}
void vcpu_unblock(struct vcpu *v)
@@ -1998,6 +2013,62 @@ static void sched_context_switch(struct vcpu *vprev, struct vcpu *vnext,
context_switch(vprev, vnext);
}
+/*
+ * Force a context switch of a single vcpu of an unit.
+ * Might be called either if a vcpu of an already running unit is woken up
+ * or if a vcpu of a running unit is put asleep with other vcpus of the same
+ * unit still running.
+ */
+static struct vcpu *sched_force_context_switch(struct vcpu *vprev,
+ struct vcpu *v,
+ int cpu, s_time_t now)
+{
+ v->force_context_switch = false;
+
+ if ( vcpu_runnable(v) == v->is_running )
+ return NULL;
+
+ if ( vcpu_runnable(v) )
+ {
+ if ( is_idle_vcpu(vprev) )
+ {
+ vcpu_runstate_change(vprev, RUNSTATE_runnable, now);
+ vprev->sched_unit = get_sched_res(cpu)->sched_unit_idle;
+ }
+ vcpu_runstate_change(v, RUNSTATE_running, now);
+ }
+ else
+ {
+ /* Make sure not to switch last vcpu of an unit away. */
+ if ( unit_running(v->sched_unit) == 1 )
+ return NULL;
+
+ v->new_state = vcpu_runstate_blocked(v);
+ vcpu_runstate_change(v, v->new_state, now);
+ v = sched_unit2vcpu_cpu(vprev->sched_unit, cpu);
+ if ( v != vprev )
+ {
+ if ( is_idle_vcpu(vprev) )
+ {
+ vcpu_runstate_change(vprev, RUNSTATE_runnable, now);
+ vprev->sched_unit = get_sched_res(cpu)->sched_unit_idle;
+ }
+ else
+ {
+ v->sched_unit = vprev->sched_unit;
+ vcpu_runstate_change(v, RUNSTATE_running, now);
+ }
+ }
+ }
+
+ v->is_running = 1;
+
+ /* Make sure not to loose another slave call. */
+ raise_softirq(SCHED_SLAVE_SOFTIRQ);
+
+ return v;
+}
+
/*
* Rendezvous before taking a scheduling decision.
* Called with schedule lock held, so all accesses to the rendezvous counter
@@ -2013,6 +2084,7 @@ static struct sched_unit *sched_wait_rendezvous_in(struct sched_unit *prev,
s_time_t now)
{
struct sched_unit *next;
+ struct vcpu *v;
if ( !--prev->rendezvous_in_cnt )
{
@@ -2021,8 +2093,28 @@ static struct sched_unit *sched_wait_rendezvous_in(struct sched_unit *prev,
return next;
}
+ v = unit2vcpu_cpu(prev, cpu);
while ( prev->rendezvous_in_cnt )
{
+ if ( v && v->force_context_switch )
+ {
+ struct vcpu *vprev = current;
+
+ v = sched_force_context_switch(vprev, v, cpu, now);
+
+ if ( v )
+ {
+ /* We'll come back another time, so adjust rendezvous_in_cnt. */
+ prev->rendezvous_in_cnt++;
+ atomic_set(&prev->rendezvous_out_cnt, 0);
+
+ pcpu_schedule_unlock_irq(*lock, cpu);
+
+ sched_context_switch(vprev, v, false, now);
+ }
+
+ v = unit2vcpu_cpu(prev, cpu);
+ }
/*
* Coming from idle might need to do tasklet work.
* In order to avoid deadlocks we can't do that here, but have to
@@ -2055,10 +2147,11 @@ static struct sched_unit *sched_wait_rendezvous_in(struct sched_unit *prev,
static void sched_slave(void)
{
- struct vcpu *vprev = current;
+ struct vcpu *v, *vprev = current;
struct sched_unit *prev = vprev->sched_unit, *next;
s_time_t now;
spinlock_t *lock;
+ bool do_softirq = false;
unsigned int cpu = smp_processor_id();
ASSERT_NOT_IN_ATOMIC();
@@ -2067,9 +2160,29 @@ static void sched_slave(void)
now = NOW();
+ v = unit2vcpu_cpu(prev, cpu);
+ if ( v && v->force_context_switch )
+ {
+ v = sched_force_context_switch(vprev, v, cpu, now);
+
+ if ( v )
+ {
+ pcpu_schedule_unlock_irq(lock, cpu);
+
+ sched_context_switch(vprev, v, false, now);
+ }
+
+ do_softirq = true;
+ }
+
if ( !prev->rendezvous_in_cnt )
{
pcpu_schedule_unlock_irq(lock, cpu);
+
+ /* Check for failed forced context switch. */
+ if ( do_softirq )
+ raise_softirq(SCHEDULE_SOFTIRQ);
+
return;
}
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 2929154d35..655eb3af32 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -100,6 +100,11 @@ static inline bool unit_runnable(const struct sched_unit *unit)
return false;
}
+static inline int vcpu_runstate_blocked(struct vcpu *v)
+{
+ return (v->pause_flags & VPF_blocked) ? RUNSTATE_blocked : RUNSTATE_offline;
+}
+
static inline bool unit_runnable_state(const struct sched_unit *unit)
{
struct vcpu *v;
@@ -112,9 +117,7 @@ static inline bool unit_runnable_state(const struct sched_unit *unit)
{
runnable = vcpu_runnable(v);
- v->new_state = runnable ? RUNSTATE_running
- : (v->pause_flags & VPF_blocked)
- ? RUNSTATE_blocked : RUNSTATE_offline;
+ v->new_state = runnable ? RUNSTATE_running : vcpu_runstate_blocked(v);
if ( runnable )
ret = true;
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index 144d353447..f276ec9398 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -186,6 +186,8 @@ struct vcpu
bool is_running;
/* VCPU should wake fast (do not deep sleep the CPU). */
bool is_urgent;
+ /* VCPU must context_switch without scheduling unit. */
+ bool force_context_switch;
#ifdef VCPU_TRAP_LAST
#define VCPU_TRAP_NONE 0
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 36/47] xen/sched: carve out freeing sched_unit memory into dedicated function
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (34 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 35/47] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 12:04 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 37/47] xen/sched: move per-cpu variable scheduler to struct sched_resource Juergen Gross
` (12 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Dario Faggioli
We'll need a way to free a sched_unit structure without side effects
in a later patch.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
RFC V2: new patch, carved out from RFC V1 patch 49
---
xen/common/schedule.c | 38 +++++++++++++++++++++-----------------
1 file changed, 21 insertions(+), 17 deletions(-)
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 1e793617ec..88ac1a1ab8 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -351,26 +351,10 @@ static void sched_spin_unlock_double(spinlock_t *lock1, spinlock_t *lock2,
spin_unlock_irqrestore(lock1, flags);
}
-static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
+static void sched_free_unit_mem(struct sched_unit *unit)
{
struct sched_unit *prev_unit;
struct domain *d = unit->domain;
- struct vcpu *vunit;
- unsigned int cnt = 0;
-
- /* Don't count to be released vcpu, might be not in vcpu list yet. */
- for_each_sched_unit_vcpu ( unit, vunit )
- if ( vunit != v )
- cnt++;
-
- v->sched_unit = NULL;
- unit->runstate_cnt[v->runstate.state]--;
-
- if ( cnt )
- return;
-
- if ( unit->vcpu_list == v )
- unit->vcpu_list = v->next_in_list;
if ( d->sched_unit_list == unit )
d->sched_unit_list = unit->next_in_list;
@@ -393,6 +377,26 @@ static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
xfree(unit);
}
+static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
+{
+ struct vcpu *vunit;
+ unsigned int cnt = 0;
+
+ /* Don't count to be released vcpu, might be not in vcpu list yet. */
+ for_each_sched_unit_vcpu ( unit, vunit )
+ if ( vunit != v )
+ cnt++;
+
+ v->sched_unit = NULL;
+ unit->runstate_cnt[v->runstate.state]--;
+
+ if ( unit->vcpu_list == v )
+ unit->vcpu_list = v->next_in_list;
+
+ if ( !cnt )
+ sched_free_unit_mem(unit);
+}
+
static void sched_unit_add_vcpu(struct sched_unit *unit, struct vcpu *v)
{
v->sched_unit = unit;
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 37/47] xen/sched: move per-cpu variable scheduler to struct sched_resource
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (35 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 36/47] xen/sched: carve out freeing sched_unit memory into dedicated function Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 12:16 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 38/47] xen/sched: move per-cpu variable cpupool " Juergen Gross
` (11 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
Having a pointer to struct scheduler in struct sched_resource instead
of per cpu is enough.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V1: new patch
---
xen/common/sched_credit.c | 18 +++++++++++-------
xen/common/sched_credit2.c | 3 ++-
xen/common/schedule.c | 15 +++++++--------
xen/include/xen/sched-if.h | 2 +-
4 files changed, 21 insertions(+), 17 deletions(-)
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index b25a7d2270..e47e865d76 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -352,9 +352,10 @@ DEFINE_PER_CPU(unsigned int, last_tickle_cpu);
static inline void __runq_tickle(struct csched_unit *new)
{
unsigned int cpu = sched_unit_cpu(new->unit);
+ struct sched_resource *sd = get_sched_res(cpu);
struct sched_unit *unit = new->unit;
struct csched_unit * const cur = CSCHED_UNIT(curr_on_cpu(cpu));
- struct csched_private *prv = CSCHED_PRIV(per_cpu(scheduler, cpu));
+ struct csched_private *prv = CSCHED_PRIV(sd->scheduler);
cpumask_t mask, idle_mask, *online;
int balance_step, idlers_empty;
@@ -931,7 +932,8 @@ csched_unit_acct(struct csched_private *prv, unsigned int cpu)
{
struct sched_unit *currunit = current->sched_unit;
struct csched_unit * const svc = CSCHED_UNIT(currunit);
- const struct scheduler *ops = per_cpu(scheduler, cpu);
+ struct sched_resource *sd = get_sched_res(cpu);
+ const struct scheduler *ops = sd->scheduler;
ASSERT( sched_unit_cpu(currunit) == cpu );
ASSERT( svc->sdom != NULL );
@@ -987,8 +989,7 @@ csched_unit_acct(struct csched_private *prv, unsigned int cpu)
* idlers. But, if we are here, it means there is someone running
* on it, and hence the bit must be zero already.
*/
- ASSERT(!cpumask_test_cpu(cpu,
- CSCHED_PRIV(per_cpu(scheduler, cpu))->idlers));
+ ASSERT(!cpumask_test_cpu(cpu, CSCHED_PRIV(sd->scheduler)->idlers));
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
}
}
@@ -1083,6 +1084,7 @@ csched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
{
struct csched_unit * const svc = CSCHED_UNIT(unit);
unsigned int cpu = sched_unit_cpu(unit);
+ struct sched_resource *sd = get_sched_res(cpu);
SCHED_STAT_CRANK(unit_sleep);
@@ -1095,7 +1097,7 @@ csched_unit_sleep(const struct scheduler *ops, struct sched_unit *unit)
* But, we are here because unit is going to sleep while running on cpu,
* so the bit must be zero already.
*/
- ASSERT(!cpumask_test_cpu(cpu, CSCHED_PRIV(per_cpu(scheduler, cpu))->idlers));
+ ASSERT(!cpumask_test_cpu(cpu, CSCHED_PRIV(sd->scheduler)->idlers));
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
}
else if ( __unit_on_runq(svc) )
@@ -1575,8 +1577,9 @@ static void
csched_tick(void *_cpu)
{
unsigned int cpu = (unsigned long)_cpu;
+ struct sched_resource *sd = get_sched_res(cpu);
struct csched_pcpu *spc = CSCHED_PCPU(cpu);
- struct csched_private *prv = CSCHED_PRIV(per_cpu(scheduler, cpu));
+ struct csched_private *prv = CSCHED_PRIV(sd->scheduler);
spc->tick++;
@@ -1601,7 +1604,8 @@ csched_tick(void *_cpu)
static struct csched_unit *
csched_runq_steal(int peer_cpu, int cpu, int pri, int balance_step)
{
- const struct csched_private * const prv = CSCHED_PRIV(per_cpu(scheduler, cpu));
+ struct sched_resource *sd = get_sched_res(cpu);
+ const struct csched_private * const prv = CSCHED_PRIV(sd->scheduler);
const struct csched_pcpu * const peer_pcpu = CSCHED_PCPU(peer_cpu);
struct csched_unit *speer;
struct list_head *iter;
diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
index 708643be7e..49c5f80ddd 100644
--- a/xen/common/sched_credit2.c
+++ b/xen/common/sched_credit2.c
@@ -3266,8 +3266,9 @@ runq_candidate(struct csched2_runqueue_data *rqd,
unsigned int *skipped)
{
struct list_head *iter, *temp;
+ struct sched_resource *sd = get_sched_res(cpu);
struct csched2_unit *snext = NULL;
- struct csched2_private *prv = csched2_priv(per_cpu(scheduler, cpu));
+ struct csched2_private *prv = csched2_priv(sd->scheduler);
bool yield = false, soft_aff_preempt = false;
*skipped = 0;
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 88ac1a1ab8..1bd84a49bc 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -69,7 +69,6 @@ static void vcpu_singleshot_timer_fn(void *data);
static void poll_timer_fn(void *data);
/* This is global for now so that private implementations can reach it */
-DEFINE_PER_CPU(struct scheduler *, scheduler);
DEFINE_PER_CPU_READ_MOSTLY(struct sched_resource *, sched_res);
static DEFINE_PER_CPU_READ_MOSTLY(unsigned int, sched_res_idx);
@@ -191,7 +190,7 @@ static inline struct scheduler *unit_scheduler(const struct sched_unit *unit)
*/
ASSERT(is_idle_domain(d));
- return per_cpu(scheduler, unit->res->master_cpu);
+ return unit->res->scheduler;
}
static inline struct scheduler *vcpu_scheduler(const struct vcpu *v)
@@ -1896,8 +1895,8 @@ static bool sched_tasklet_check(unsigned int cpu)
static struct sched_unit *do_schedule(struct sched_unit *prev, s_time_t now,
unsigned int cpu)
{
- struct scheduler *sched = per_cpu(scheduler, cpu);
struct sched_resource *sd = get_sched_res(cpu);
+ struct scheduler *sched = sd->scheduler;
struct sched_unit *next;
/* get policy-specific decision on scheduling... */
@@ -2302,7 +2301,7 @@ static int cpu_schedule_up(unsigned int cpu)
sd->cpus = cpumask_of(cpu);
set_sched_res(cpu, sd);
- per_cpu(scheduler, cpu) = &sched_idle_ops;
+ sd->scheduler = &sched_idle_ops;
spin_lock_init(&sd->_lock);
sd->schedule_lock = &sched_free_cpu_lock;
init_timer(&sd->s_timer, s_timer_fn, NULL, cpu);
@@ -2513,7 +2512,7 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c)
{
struct vcpu *idle;
void *ppriv, *ppriv_old, *vpriv, *vpriv_old;
- struct scheduler *old_ops = per_cpu(scheduler, cpu);
+ struct scheduler *old_ops = get_sched_res(cpu)->scheduler;
struct scheduler *new_ops = (c == NULL) ? &sched_idle_ops : c->sched;
struct cpupool *old_pool = per_cpu(cpupool, cpu);
struct sched_resource *sd = get_sched_res(cpu);
@@ -2577,7 +2576,7 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c)
ppriv_old = sd->sched_priv;
new_lock = sched_switch_sched(new_ops, cpu, ppriv, vpriv);
- per_cpu(scheduler, cpu) = new_ops;
+ sd->scheduler = new_ops;
sd->sched_priv = ppriv;
/*
@@ -2677,7 +2676,7 @@ void sched_tick_suspend(void)
struct scheduler *sched;
unsigned int cpu = smp_processor_id();
- sched = per_cpu(scheduler, cpu);
+ sched = get_sched_res(cpu)->scheduler;
sched_do_tick_suspend(sched, cpu);
rcu_idle_enter(cpu);
rcu_idle_timer_start();
@@ -2690,7 +2689,7 @@ void sched_tick_resume(void)
rcu_idle_timer_stop();
rcu_idle_exit(cpu);
- sched = per_cpu(scheduler, cpu);
+ sched = get_sched_res(cpu)->scheduler;
sched_do_tick_resume(sched, cpu);
}
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 655eb3af32..528874ab11 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -36,6 +36,7 @@ extern const cpumask_t *sched_res_mask;
* as the rest of the struct. Just have the scheduler point to the
* one it wants (This may be the one right in front of it).*/
struct sched_resource {
+ struct scheduler *scheduler;
spinlock_t *schedule_lock,
_lock;
struct sched_unit *curr;
@@ -51,7 +52,6 @@ struct sched_resource {
#define curr_on_cpu(c) (get_sched_res(c)->curr)
-DECLARE_PER_CPU(struct scheduler *, scheduler);
DECLARE_PER_CPU(struct cpupool *, cpupool);
DECLARE_PER_CPU(struct sched_resource *, sched_res);
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 38/47] xen/sched: move per-cpu variable cpupool to struct sched_resource
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (36 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 37/47] xen/sched: move per-cpu variable scheduler to struct sched_resource Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 13:10 ` Jan Beulich
2019-09-26 9:09 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 39/47] xen/sched: reject switching smt on/off with core scheduling active Juergen Gross
` (10 subsequent siblings)
48 siblings, 2 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Meng Xu, Jan Beulich
Having a pointer to struct cpupool in struct sched_resource instead
of per cpu is enough.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V1: new patch
---
xen/common/cpupool.c | 4 +---
xen/common/sched_credit.c | 2 +-
xen/common/sched_rt.c | 2 +-
xen/common/schedule.c | 8 ++++----
xen/include/xen/sched-if.h | 2 +-
5 files changed, 8 insertions(+), 10 deletions(-)
diff --git a/xen/common/cpupool.c b/xen/common/cpupool.c
index a5f4113915..e0333a8417 100644
--- a/xen/common/cpupool.c
+++ b/xen/common/cpupool.c
@@ -34,8 +34,6 @@ static cpumask_t cpupool_locked_cpus;
static DEFINE_SPINLOCK(cpupool_lock);
-DEFINE_PER_CPU(struct cpupool *, cpupool);
-
static void free_cpupool_struct(struct cpupool *c)
{
if ( c )
@@ -506,7 +504,7 @@ static int cpupool_cpu_add(unsigned int cpu)
* (or unplugging would have failed) and that is the default behavior
* anyway.
*/
- per_cpu(cpupool, cpu) = NULL;
+ get_sched_res(cpu)->cpupool = NULL;
ret = cpupool_assign_cpu_locked(cpupool0, cpu);
spin_unlock(&cpupool_lock);
diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c
index e47e865d76..41699f6b32 100644
--- a/xen/common/sched_credit.c
+++ b/xen/common/sched_credit.c
@@ -1681,7 +1681,7 @@ static struct csched_unit *
csched_load_balance(struct csched_private *prv, int cpu,
struct csched_unit *snext, bool *stolen)
{
- struct cpupool *c = per_cpu(cpupool, cpu);
+ struct cpupool *c = get_sched_res(cpu)->cpupool;
struct csched_unit *speer;
cpumask_t workers;
cpumask_t *online;
diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c
index 9f4e397334..d7eb6931ef 100644
--- a/xen/common/sched_rt.c
+++ b/xen/common/sched_rt.c
@@ -775,7 +775,7 @@ rt_deinit_pdata(const struct scheduler *ops, void *pcpu, int cpu)
if ( prv->repl_timer.cpu == cpu )
{
- struct cpupool *c = per_cpu(cpupool, cpu);
+ struct cpupool *c = get_sched_res(cpu)->cpupool;
unsigned int new_cpu = cpumask_cycle(cpu, cpupool_online_cpumask(c));
/*
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 1bd84a49bc..e360c9ec9f 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -1093,7 +1093,7 @@ int cpu_disable_scheduler(unsigned int cpu)
cpumask_t online_affinity;
int ret = 0;
- c = per_cpu(cpupool, cpu);
+ c = get_sched_res(cpu)->cpupool;
if ( c == NULL )
return ret;
@@ -1162,7 +1162,7 @@ static int cpu_disable_scheduler_check(unsigned int cpu)
struct cpupool *c;
struct vcpu *v;
- c = per_cpu(cpupool, cpu);
+ c = get_sched_res(cpu)->cpupool;
if ( c == NULL )
return 0;
@@ -2514,8 +2514,8 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c)
void *ppriv, *ppriv_old, *vpriv, *vpriv_old;
struct scheduler *old_ops = get_sched_res(cpu)->scheduler;
struct scheduler *new_ops = (c == NULL) ? &sched_idle_ops : c->sched;
- struct cpupool *old_pool = per_cpu(cpupool, cpu);
struct sched_resource *sd = get_sched_res(cpu);
+ struct cpupool *old_pool = sd->cpupool;
spinlock_t *old_lock, *new_lock;
unsigned long flags;
@@ -2597,7 +2597,7 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c)
sched_free_vdata(old_ops, vpriv_old);
sched_free_pdata(old_ops, ppriv_old, cpu);
- per_cpu(cpupool, cpu) = c;
+ get_sched_res(cpu)->cpupool = c;
/* When a cpu is added to a pool, trigger it to go pick up some work */
if ( c != NULL )
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 528874ab11..5625cafb6e 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -37,6 +37,7 @@ extern const cpumask_t *sched_res_mask;
* one it wants (This may be the one right in front of it).*/
struct sched_resource {
struct scheduler *scheduler;
+ struct cpupool *cpupool;
spinlock_t *schedule_lock,
_lock;
struct sched_unit *curr;
@@ -52,7 +53,6 @@ struct sched_resource {
#define curr_on_cpu(c) (get_sched_res(c)->curr)
-DECLARE_PER_CPU(struct cpupool *, cpupool);
DECLARE_PER_CPU(struct sched_resource *, sched_res);
static inline struct sched_resource *get_sched_res(unsigned int cpu)
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 39/47] xen/sched: reject switching smt on/off with core scheduling active
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (37 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 38/47] xen/sched: move per-cpu variable cpupool " Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-26 9:10 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 40/47] xen/sched: prepare per-cpupool scheduling granularity Juergen Gross
` (9 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Tim Deegan, Julien Grall, Jan Beulich, Dario Faggioli,
Roger Pau Monné
When core or socket scheduling are active enabling or disabling smt is
not possible as that would require a major host reconfiguration.
Add a bool sched_disable_smt_switching which will be set for core or
socket scheduling.
Signed-off-by: Juergen Gross <jgross@suse.com>
Acked-by: Jan Beulich <jbeulich@suse.com>
---
V1:
- new patch
V2:
- EBUSY as return code (Jan Beulich, Dario Faggioli)
- __read_mostly for sched_disable_smt_switching (Jan Beulich)
---
xen/arch/x86/sysctl.c | 5 +++++
xen/common/schedule.c | 1 +
xen/include/xen/sched.h | 1 +
3 files changed, 7 insertions(+)
diff --git a/xen/arch/x86/sysctl.c b/xen/arch/x86/sysctl.c
index 50be0c722a..e2ef60d2e7 100644
--- a/xen/arch/x86/sysctl.c
+++ b/xen/arch/x86/sysctl.c
@@ -206,6 +206,11 @@ long arch_do_sysctl(
ret = -EOPNOTSUPP;
break;
}
+ if ( sched_disable_smt_switching )
+ {
+ ret = -EBUSY;
+ break;
+ }
plug = op == XEN_SYSCTL_CPU_HOTPLUG_SMT_ENABLE;
fn = smt_up_down_helper;
hcpu = _p(plug);
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index e360c9ec9f..e5b7678dc0 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -57,6 +57,7 @@ integer_param("sched_ratelimit_us", sched_ratelimit_us);
/* Number of vcpus per struct sched_unit. */
static unsigned int __read_mostly sched_granularity = 1;
+bool __read_mostly sched_disable_smt_switching;
const cpumask_t *sched_res_mask = &cpumask_all;
/* Common lock for free cpus. */
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index f276ec9398..e943b06646 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -1040,6 +1040,7 @@ static inline bool is_xenstore_domain(const struct domain *d)
}
extern bool sched_smt_power_savings;
+extern bool sched_disable_smt_switching;
extern enum cpufreq_controller {
FREQCTL_none, FREQCTL_dom0_kernel, FREQCTL_xen
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 40/47] xen/sched: prepare per-cpupool scheduling granularity
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (38 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 39/47] xen/sched: reject switching smt on/off with core scheduling active Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 13:34 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 41/47] xen/sched: split schedule_cpu_switch() Juergen Gross
` (8 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
On- and offlining cpus with core scheduling is rather complicated as
the cpus are taken on- or offline one by one, but scheduling wants them
rather to be handled per core.
As the future plan is to be able to select scheduling granularity per
cpupool prepare that by storing the granularity in struct cpupool and
struct sched_resource (we need it there for free cpus which are not
associated to any cpupool). Free cpus will always use granularity 1.
Store the selected granularity option (cpu, core or socket) in the
cpupool as well, as we will need it to select the appropriate cpu mask
when populating the cpupool with cpus.
This will make on- and offlining of cpus much easier and avoids
writing code which would needed to be thrown away later.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V1: new patch
---
xen/common/cpupool.c | 2 ++
xen/common/schedule.c | 27 +++++++++++++++++----------
xen/include/xen/sched-if.h | 12 ++++++++++++
3 files changed, 31 insertions(+), 10 deletions(-)
diff --git a/xen/common/cpupool.c b/xen/common/cpupool.c
index e0333a8417..c7d8a748d4 100644
--- a/xen/common/cpupool.c
+++ b/xen/common/cpupool.c
@@ -175,6 +175,8 @@ static struct cpupool *cpupool_create(
return NULL;
}
}
+ c->granularity = sched_granularity;
+ c->opt_granularity = opt_sched_granularity;
*q = c;
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index e5b7678dc0..b3c1aa0821 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -56,7 +56,8 @@ int sched_ratelimit_us = SCHED_DEFAULT_RATELIMIT_US;
integer_param("sched_ratelimit_us", sched_ratelimit_us);
/* Number of vcpus per struct sched_unit. */
-static unsigned int __read_mostly sched_granularity = 1;
+enum sched_gran __read_mostly opt_sched_granularity = SCHED_GRAN_cpu;
+unsigned int __read_mostly sched_granularity = 1;
bool __read_mostly sched_disable_smt_switching;
const cpumask_t *sched_res_mask = &cpumask_all;
@@ -412,10 +413,10 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
{
struct sched_unit *unit, **prev_unit;
struct domain *d = v->domain;
+ unsigned int gran = d->cpupool ? d->cpupool->granularity : 1;
for_each_sched_unit ( d, unit )
- if ( unit->vcpu_list->vcpu_id / sched_granularity ==
- v->vcpu_id / sched_granularity )
+ if ( unit->vcpu_list->vcpu_id / gran == v->vcpu_id / gran )
break;
if ( unit )
@@ -582,7 +583,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
return PTR_ERR(domdata);
unit_priv = xzalloc_array(void *,
- DIV_ROUND_UP(d->max_vcpus, sched_granularity));
+ DIV_ROUND_UP(d->max_vcpus, c->granularity));
if ( unit_priv == NULL )
{
sched_free_domdata(c->sched, domdata);
@@ -1825,11 +1826,11 @@ static void sched_switch_units(struct sched_resource *sd,
if ( is_idle_unit(prev) )
{
prev->runstate_cnt[RUNSTATE_running] = 0;
- prev->runstate_cnt[RUNSTATE_runnable] = sched_granularity;
+ prev->runstate_cnt[RUNSTATE_runnable] = sd->granularity;
}
if ( is_idle_unit(next) )
{
- next->runstate_cnt[RUNSTATE_running] = sched_granularity;
+ next->runstate_cnt[RUNSTATE_running] = sd->granularity;
next->runstate_cnt[RUNSTATE_runnable] = 0;
}
}
@@ -1978,7 +1979,7 @@ void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
else
{
vcpu_context_saved(vprev, vnext);
- if ( sched_granularity == 1 )
+ if ( sd->granularity == 1 )
unit_context_saved(sd);
}
@@ -2089,11 +2090,12 @@ static struct sched_unit *sched_wait_rendezvous_in(struct sched_unit *prev,
{
struct sched_unit *next;
struct vcpu *v;
+ unsigned int gran = get_sched_res(cpu)->granularity;
if ( !--prev->rendezvous_in_cnt )
{
next = do_schedule(prev, now, cpu);
- atomic_set(&next->rendezvous_out_cnt, sched_granularity + 1);
+ atomic_set(&next->rendezvous_out_cnt, gran + 1);
return next;
}
@@ -2213,6 +2215,7 @@ static void schedule(void)
struct sched_resource *sd;
spinlock_t *lock;
int cpu = smp_processor_id();
+ unsigned int gran = get_sched_res(cpu)->granularity;
ASSERT_NOT_IN_ATOMIC();
@@ -2238,11 +2241,11 @@ static void schedule(void)
stop_timer(&sd->s_timer);
- if ( sched_granularity > 1 )
+ if ( gran > 1 )
{
cpumask_t mask;
- prev->rendezvous_in_cnt = sched_granularity;
+ prev->rendezvous_in_cnt = gran;
cpumask_andnot(&mask, sd->cpus, cpumask_of(cpu));
cpumask_raise_softirq(&mask, SCHED_SLAVE_SOFTIRQ);
next = sched_wait_rendezvous_in(prev, &lock, cpu, now);
@@ -2308,6 +2311,9 @@ static int cpu_schedule_up(unsigned int cpu)
init_timer(&sd->s_timer, s_timer_fn, NULL, cpu);
atomic_set(&per_cpu(sched_urgent_count, cpu), 0);
+ /* We start with cpu granularity. */
+ sd->granularity = 1;
+
/* Boot CPU is dealt with later in scheduler_init(). */
if ( cpu == 0 )
return 0;
@@ -2598,6 +2604,7 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c)
sched_free_vdata(old_ops, vpriv_old);
sched_free_pdata(old_ops, ppriv_old, cpu);
+ get_sched_res(cpu)->granularity = c ? c->granularity : 1;
get_sched_res(cpu)->cpupool = c;
/* When a cpu is added to a pool, trigger it to go pick up some work */
if ( c != NULL )
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 5625cafb6e..cb58bad0ff 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -25,6 +25,15 @@ extern int sched_ratelimit_us;
/* Scheduling resource mask. */
extern const cpumask_t *sched_res_mask;
+/* Number of vcpus per struct sched_unit. */
+enum sched_gran {
+ SCHED_GRAN_cpu,
+ SCHED_GRAN_core,
+ SCHED_GRAN_socket
+};
+extern enum sched_gran opt_sched_granularity;
+extern unsigned int sched_granularity;
+
/*
* In order to allow a scheduler to remap the lock->cpu mapping,
* we have a per-cpu pointer, along with a pre-allocated set of
@@ -48,6 +57,7 @@ struct sched_resource {
/* Cpu with lowest id in scheduling resource. */
unsigned int master_cpu;
+ unsigned int granularity;
const cpumask_t *cpus; /* cpus covered by this struct */
};
@@ -532,6 +542,8 @@ struct cpupool
struct cpupool *next;
struct scheduler *sched;
atomic_t refcnt;
+ unsigned int granularity;
+ enum sched_gran opt_granularity;
};
#define cpupool_online_cpumask(_pool) \
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 41/47] xen/sched: split schedule_cpu_switch()
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (39 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 40/47] xen/sched: prepare per-cpupool scheduling granularity Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 42/47] xen/sched: protect scheduling resource via rcu Juergen Gross
` (7 subsequent siblings)
48 siblings, 0 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
Instead of letting schedule_cpu_switch() handle moving cpus from and
to cpupools, split it into schedule_cpu_add() and schedule_cpu_rm().
This will allow us to drop allocating/freeing scheduler data for free
cpus as the idle scheduler doesn't need such data.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V1: new patch
---
xen/common/cpupool.c | 4 +-
xen/common/schedule.c | 125 +++++++++++++++++++++++++++---------------------
xen/include/xen/sched.h | 3 +-
3 files changed, 74 insertions(+), 58 deletions(-)
diff --git a/xen/common/cpupool.c b/xen/common/cpupool.c
index c7d8a748d4..c3c1109be9 100644
--- a/xen/common/cpupool.c
+++ b/xen/common/cpupool.c
@@ -266,7 +266,7 @@ static int cpupool_assign_cpu_locked(struct cpupool *c, unsigned int cpu)
if ( (cpupool_moving_cpu == cpu) && (c != cpupool_cpu_moving) )
return -EADDRNOTAVAIL;
- ret = schedule_cpu_switch(cpu, c);
+ ret = schedule_cpu_add(cpu, c);
if ( ret )
return ret;
@@ -316,7 +316,7 @@ static int cpupool_unassign_cpu_finish(struct cpupool *c)
*/
if ( !ret )
{
- ret = schedule_cpu_switch(cpu, NULL);
+ ret = schedule_cpu_rm(cpu);
if ( ret )
cpumask_clear_cpu(cpu, &cpupool_free_cpus);
else
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index b3c1aa0821..86ddca83e9 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -86,15 +86,6 @@ extern const struct scheduler *__start_schedulers_array[], *__end_schedulers_arr
static struct scheduler __read_mostly ops;
-static spinlock_t *
-sched_idle_switch_sched(struct scheduler *new_ops, unsigned int cpu,
- void *pdata, void *vdata)
-{
- sched_idle_unit(cpu)->priv = NULL;
-
- return &sched_free_cpu_lock;
-}
-
static struct sched_resource *
sched_idle_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
@@ -134,7 +125,6 @@ static struct scheduler sched_idle_ops = {
.alloc_vdata = sched_idle_alloc_vdata,
.free_vdata = sched_idle_free_vdata,
- .switch_sched = sched_idle_switch_sched,
};
static inline struct vcpu *unit2vcpu_cpu(struct sched_unit *unit,
@@ -2509,36 +2499,22 @@ void __init scheduler_init(void)
}
/*
- * Move a pCPU outside of the influence of the scheduler of its current
- * cpupool, or subject it to the scheduler of a new cpupool.
- *
- * For the pCPUs that are removed from their cpupool, their scheduler becomes
- * &sched_idle_ops (the idle scheduler).
+ * Move a pCPU from free cpus (running the idle scheduler) to a cpupool
+ * using any "real" scheduler.
+ * The cpu is still marked as "free" and not yet valid for its cpupool.
*/
-int schedule_cpu_switch(unsigned int cpu, struct cpupool *c)
+int schedule_cpu_add(unsigned int cpu, struct cpupool *c)
{
struct vcpu *idle;
- void *ppriv, *ppriv_old, *vpriv, *vpriv_old;
- struct scheduler *old_ops = get_sched_res(cpu)->scheduler;
- struct scheduler *new_ops = (c == NULL) ? &sched_idle_ops : c->sched;
+ void *ppriv, *vpriv;
+ struct scheduler *new_ops = c->sched;
struct sched_resource *sd = get_sched_res(cpu);
- struct cpupool *old_pool = sd->cpupool;
spinlock_t *old_lock, *new_lock;
unsigned long flags;
- /*
- * pCPUs only move from a valid cpupool to free (i.e., out of any pool),
- * or from free to a valid cpupool. In the former case (which happens when
- * c is NULL), we want the CPU to have been marked as free already, as
- * well as to not be valid for the source pool any longer, when we get to
- * here. In the latter case (which happens when c is a valid cpupool), we
- * want the CPU to still be marked as free, as well as to not yet be valid
- * for the destination pool.
- */
- ASSERT(c != old_pool && (c != NULL || old_pool != NULL));
ASSERT(cpumask_test_cpu(cpu, &cpupool_free_cpus));
- ASSERT((c == NULL && !cpumask_test_cpu(cpu, old_pool->cpu_valid)) ||
- (c != NULL && !cpumask_test_cpu(cpu, c->cpu_valid)));
+ ASSERT(!cpumask_test_cpu(cpu, c->cpu_valid));
+ ASSERT(get_sched_res(cpu)->cpupool == NULL);
/*
* To setup the cpu for the new scheduler we need:
@@ -2563,52 +2539,91 @@ int schedule_cpu_switch(unsigned int cpu, struct cpupool *c)
return -ENOMEM;
}
- sched_do_tick_suspend(old_ops, cpu);
-
/*
- * The actual switch, including (if necessary) the rerouting of the
- * scheduler lock to whatever new_ops prefers, needs to happen in one
- * critical section, protected by old_ops' lock, or races are possible.
- * It is, in fact, the lock of another scheduler that we are taking (the
- * scheduler of the cpupool that cpu still belongs to). But that is ok
- * as, anyone trying to schedule on this cpu will spin until when we
- * release that lock (bottom of this function). When he'll get the lock
- * --thanks to the loop inside *_schedule_lock() functions-- he'll notice
- * that the lock itself changed, and retry acquiring the new one (which
- * will be the correct, remapped one, at that point).
+ * The actual switch, including the rerouting of the scheduler lock to
+ * whatever new_ops prefers, needs to happen in one critical section,
+ * protected by old_ops' lock, or races are possible.
+ * It is, in fact, the lock of the idle scheduler that we are taking.
+ * But that is ok as anyone trying to schedule on this cpu will spin until
+ * when we release that lock (bottom of this function). When he'll get the
+ * lock --thanks to the loop inside *_schedule_lock() functions-- he'll
+ * notice that the lock itself changed, and retry acquiring the new one
+ * (which will be the correct, remapped one, at that point).
*/
old_lock = pcpu_schedule_lock_irqsave(cpu, &flags);
- vpriv_old = idle->sched_unit->priv;
- ppriv_old = sd->sched_priv;
new_lock = sched_switch_sched(new_ops, cpu, ppriv, vpriv);
sd->scheduler = new_ops;
sd->sched_priv = ppriv;
/*
- * The data above is protected under new_lock, which may be unlocked.
- * Another CPU can take new_lock as soon as sd->schedule_lock is visible,
- * and must observe all prior initialisation.
+ * Reroute the lock to the per pCPU lock as /last/ thing. In fact,
+ * if it is free (and it can be) we want that anyone that manages
+ * taking it, finds all the initializations we've done above in place.
*/
smp_wmb();
sd->schedule_lock = new_lock;
- /* _Not_ pcpu_schedule_unlock(): schedule_lock may have changed! */
+ /* _Not_ pcpu_schedule_unlock(): schedule_lock has changed! */
spin_unlock_irqrestore(old_lock, flags);
sched_do_tick_resume(new_ops, cpu);
+ sd->granularity = c->granularity;
+ sd->cpupool = c;
+ /* The cpu is added to a pool, trigger it to go pick up some work */
+ cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
+
+ return 0;
+}
+
+/*
+ * Remove a pCPU from its cpupool. Its scheduler becomes &sched_idle_ops
+ * (the idle scheduler).
+ * The cpu is already marked as "free" and not valid any longer for its
+ * cpupool.
+ */
+int schedule_cpu_rm(unsigned int cpu)
+{
+ struct vcpu *idle;
+ void *ppriv_old, *vpriv_old;
+ struct sched_resource *sd = get_sched_res(cpu);
+ struct scheduler *old_ops = sd->scheduler;
+ spinlock_t *old_lock;
+ unsigned long flags;
+
+ ASSERT(sd->cpupool != NULL);
+ ASSERT(cpumask_test_cpu(cpu, &cpupool_free_cpus));
+ ASSERT(!cpumask_test_cpu(cpu, sd->cpupool->cpu_valid));
+
+ idle = idle_vcpu[cpu];
+
+ sched_do_tick_suspend(old_ops, cpu);
+
+ /* See comment in schedule_cpu_add() regarding lock switching. */
+ old_lock = pcpu_schedule_lock_irqsave(cpu, &flags);
+
+ vpriv_old = idle->sched_unit->priv;
+ ppriv_old = sd->sched_priv;
+
+ idle->sched_unit->priv = NULL;
+ sd->scheduler = &sched_idle_ops;
+ sd->sched_priv = NULL;
+
+ smp_mb();
+ sd->schedule_lock = &sched_free_cpu_lock;
+
+ /* _Not_ pcpu_schedule_unlock(): schedule_lock may have changed! */
+ spin_unlock_irqrestore(old_lock, flags);
+
sched_deinit_pdata(old_ops, ppriv_old, cpu);
sched_free_vdata(old_ops, vpriv_old);
sched_free_pdata(old_ops, ppriv_old, cpu);
- get_sched_res(cpu)->granularity = c ? c->granularity : 1;
- get_sched_res(cpu)->cpupool = c;
- /* When a cpu is added to a pool, trigger it to go pick up some work */
- if ( c != NULL )
- cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
+ sd->granularity = 1;
+ sd->cpupool = NULL;
return 0;
}
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index e943b06646..cc65922b88 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -918,7 +918,8 @@ struct scheduler;
struct scheduler *scheduler_get_default(void);
struct scheduler *scheduler_alloc(unsigned int sched_id, int *perr);
void scheduler_free(struct scheduler *sched);
-int schedule_cpu_switch(unsigned int cpu, struct cpupool *c);
+int schedule_cpu_add(unsigned int cpu, struct cpupool *c);
+int schedule_cpu_rm(unsigned int cpu);
void vcpu_set_periodic_timer(struct vcpu *v, s_time_t value);
int cpu_disable_scheduler(unsigned int cpu);
/* We need it in dom0_setup_vcpu */
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 42/47] xen/sched: protect scheduling resource via rcu
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (40 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 41/47] xen/sched: split schedule_cpu_switch() Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 43/47] xen/sched: support multiple cpus per scheduling resource Juergen Gross
` (6 subsequent siblings)
48 siblings, 0 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
In order to be able to move cpus to cpupools with core scheduling
active it is mandatory to merge multiple cpus into one scheduling
resource or to split a scheduling resource with multiple cpus in it
into multiple scheduling resources. This in turn requires to modify
the cpu <-> scheduling resource relation. In order to be able to free
unused resources protect struct sched_resource via RCU. This ensures
there are no users left when freeing such a resource.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V1: new patch
---
xen/common/cpupool.c | 4 +
xen/common/schedule.c | 187 ++++++++++++++++++++++++++++++++++++++++-----
xen/include/xen/sched-if.h | 7 +-
3 files changed, 178 insertions(+), 20 deletions(-)
diff --git a/xen/common/cpupool.c b/xen/common/cpupool.c
index c3c1109be9..f53ceec3ab 100644
--- a/xen/common/cpupool.c
+++ b/xen/common/cpupool.c
@@ -506,8 +506,10 @@ static int cpupool_cpu_add(unsigned int cpu)
* (or unplugging would have failed) and that is the default behavior
* anyway.
*/
+ rcu_read_lock(&sched_res_rculock);
get_sched_res(cpu)->cpupool = NULL;
ret = cpupool_assign_cpu_locked(cpupool0, cpu);
+ rcu_read_unlock(&sched_res_rculock);
spin_unlock(&cpupool_lock);
@@ -592,7 +594,9 @@ static void cpupool_cpu_remove_forced(unsigned int cpu)
}
}
+ rcu_read_lock(&sched_res_rculock);
sched_rm_cpu(cpu);
+ rcu_read_unlock(&sched_res_rculock);
}
/*
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 86ddca83e9..c2e5a9220d 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -73,6 +73,7 @@ static void poll_timer_fn(void *data);
/* This is global for now so that private implementations can reach it */
DEFINE_PER_CPU_READ_MOSTLY(struct sched_resource *, sched_res);
static DEFINE_PER_CPU_READ_MOSTLY(unsigned int, sched_res_idx);
+DEFINE_RCU_READ_LOCK(sched_res_rculock);
/* Scratch space for cpumasks. */
DEFINE_PER_CPU(cpumask_t, cpumask_scratch);
@@ -286,10 +287,12 @@ void sched_guest_idle(void (*idle) (void), unsigned int cpu)
void vcpu_runstate_get(struct vcpu *v, struct vcpu_runstate_info *runstate)
{
- spinlock_t *lock = likely(v == current)
- ? NULL : unit_schedule_lock_irq(v->sched_unit);
+ spinlock_t *lock;
s_time_t delta;
+ rcu_read_lock(&sched_res_rculock);
+
+ lock = likely(v == current) ? NULL : unit_schedule_lock_irq(v->sched_unit);
memcpy(runstate, &v->runstate, sizeof(*runstate));
delta = NOW() - runstate->state_entry_time;
if ( delta > 0 )
@@ -297,6 +300,8 @@ void vcpu_runstate_get(struct vcpu *v, struct vcpu_runstate_info *runstate)
if ( unlikely(lock != NULL) )
unit_schedule_unlock_irq(lock, v->sched_unit);
+
+ rcu_read_unlock(&sched_res_rculock);
}
uint64_t get_cpu_idle_time(unsigned int cpu)
@@ -501,6 +506,8 @@ int sched_init_vcpu(struct vcpu *v)
return 0;
}
+ rcu_read_lock(&sched_res_rculock);
+
/* The first vcpu of an unit can be set via sched_set_res(). */
sched_set_res(unit, get_sched_res(processor));
@@ -508,6 +515,7 @@ int sched_init_vcpu(struct vcpu *v)
if ( unit->priv == NULL )
{
sched_free_unit(unit, v);
+ rcu_read_unlock(&sched_res_rculock);
return 1;
}
@@ -534,6 +542,8 @@ int sched_init_vcpu(struct vcpu *v)
sched_insert_unit(dom_scheduler(d), unit);
}
+ rcu_read_unlock(&sched_res_rculock);
+
return 0;
}
@@ -561,6 +571,7 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
void *unitdata;
struct scheduler *old_ops;
void *old_domdata;
+ int ret = 0;
for_each_vcpu ( d, v )
{
@@ -568,16 +579,22 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
return -EBUSY;
}
+ rcu_read_lock(&sched_res_rculock);
+
domdata = sched_alloc_domdata(c->sched, d);
if ( IS_ERR(domdata) )
- return PTR_ERR(domdata);
+ {
+ ret = PTR_ERR(domdata);
+ goto out;
+ }
unit_priv = xzalloc_array(void *,
DIV_ROUND_UP(d->max_vcpus, c->granularity));
if ( unit_priv == NULL )
{
sched_free_domdata(c->sched, domdata);
- return -ENOMEM;
+ ret = -ENOMEM;
+ goto out;
}
unit_idx = 0;
@@ -590,7 +607,8 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
sched_free_vdata(c->sched, unit_priv[unit_idx]);
xfree(unit_priv);
sched_free_domdata(c->sched, domdata);
- return -ENOMEM;
+ ret = -ENOMEM;
+ goto out;
}
unit_idx++;
}
@@ -656,7 +674,10 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
xfree(unit_priv);
- return 0;
+out:
+ rcu_read_unlock(&sched_res_rculock);
+
+ return ret;
}
void sched_destroy_vcpu(struct vcpu *v)
@@ -674,9 +695,13 @@ void sched_destroy_vcpu(struct vcpu *v)
*/
if ( unit->vcpu_list == v )
{
+ rcu_read_lock(&sched_res_rculock);
+
sched_remove_unit(vcpu_scheduler(v), unit);
sched_free_vdata(vcpu_scheduler(v), unit->priv);
sched_free_unit(unit, v);
+
+ rcu_read_unlock(&sched_res_rculock);
}
}
@@ -694,7 +719,12 @@ int sched_init_domain(struct domain *d, int poolid)
SCHED_STAT_CRANK(dom_init);
TRACE_1D(TRC_SCHED_DOM_ADD, d->domain_id);
+ rcu_read_lock(&sched_res_rculock);
+
sdom = sched_alloc_domdata(dom_scheduler(d), d);
+
+ rcu_read_unlock(&sched_res_rculock);
+
if ( IS_ERR(sdom) )
return PTR_ERR(sdom);
@@ -712,9 +742,13 @@ void sched_destroy_domain(struct domain *d)
SCHED_STAT_CRANK(dom_destroy);
TRACE_1D(TRC_SCHED_DOM_REM, d->domain_id);
+ rcu_read_lock(&sched_res_rculock);
+
sched_free_domdata(dom_scheduler(d), d->sched_priv);
d->sched_priv = NULL;
+ rcu_read_unlock(&sched_res_rculock);
+
cpupool_rm_domain(d);
}
}
@@ -748,11 +782,15 @@ void vcpu_sleep_nosync(struct vcpu *v)
TRACE_2D(TRC_SCHED_SLEEP, v->domain->domain_id, v->vcpu_id);
+ rcu_read_lock(&sched_res_rculock);
+
lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
vcpu_sleep_nosync_locked(v);
unit_schedule_unlock_irqrestore(lock, flags, v->sched_unit);
+
+ rcu_read_unlock(&sched_res_rculock);
}
void vcpu_sleep_sync(struct vcpu *v)
@@ -773,6 +811,8 @@ void vcpu_wake(struct vcpu *v)
TRACE_2D(TRC_SCHED_WAKE, v->domain->domain_id, v->vcpu_id);
+ rcu_read_lock(&sched_res_rculock);
+
lock = unit_schedule_lock_irqsave(unit, &flags);
if ( likely(vcpu_runnable(v)) )
@@ -793,6 +833,8 @@ void vcpu_wake(struct vcpu *v)
}
unit_schedule_unlock_irqrestore(lock, flags, unit);
+
+ rcu_read_unlock(&sched_res_rculock);
}
void vcpu_unblock(struct vcpu *v)
@@ -826,6 +868,8 @@ static void sched_unit_move_locked(struct sched_unit *unit,
unsigned int old_cpu = unit->res->master_cpu;
struct vcpu *v;
+ rcu_read_lock(&sched_res_rculock);
+
/*
* Transfer urgency status to new CPU before switching CPUs, as
* once the switch occurs, v->is_urgent is no longer protected by
@@ -845,6 +889,8 @@ static void sched_unit_move_locked(struct sched_unit *unit,
* pointer can't change while the current lock is held.
*/
sched_migrate(unit_scheduler(unit), unit, new_cpu);
+
+ rcu_read_unlock(&sched_res_rculock);
}
/*
@@ -1012,6 +1058,8 @@ void restore_vcpu_affinity(struct domain *d)
ASSERT(system_state == SYS_STATE_resume);
+ rcu_read_lock(&sched_res_rculock);
+
for_each_sched_unit ( d, unit )
{
spinlock_t *lock;
@@ -1070,6 +1118,8 @@ void restore_vcpu_affinity(struct domain *d)
sched_move_irqs(unit);
}
+ rcu_read_unlock(&sched_res_rculock);
+
domain_update_node_affinity(d);
}
@@ -1085,9 +1135,11 @@ int cpu_disable_scheduler(unsigned int cpu)
cpumask_t online_affinity;
int ret = 0;
+ rcu_read_lock(&sched_res_rculock);
+
c = get_sched_res(cpu)->cpupool;
if ( c == NULL )
- return ret;
+ goto out;
for_each_domain_in_cpupool ( d, c )
{
@@ -1145,6 +1197,9 @@ int cpu_disable_scheduler(unsigned int cpu)
}
}
+out:
+ rcu_read_unlock(&sched_res_rculock);
+
return ret;
}
@@ -1178,7 +1233,9 @@ void sched_set_affinity(
{
struct sched_unit *unit = v->sched_unit;
+ rcu_read_lock(&sched_res_rculock);
sched_adjust_affinity(dom_scheduler(v->domain), unit, hard, soft);
+ rcu_read_unlock(&sched_res_rculock);
if ( hard )
cpumask_copy(unit->cpu_hard_affinity, hard);
@@ -1198,6 +1255,8 @@ static int vcpu_set_affinity(
spinlock_t *lock;
int ret = 0;
+ rcu_read_lock(&sched_res_rculock);
+
lock = unit_schedule_lock_irq(unit);
if ( v->affinity_broken )
@@ -1226,6 +1285,8 @@ static int vcpu_set_affinity(
sched_unit_migrate_finish(unit);
+ rcu_read_unlock(&sched_res_rculock);
+
return ret;
}
@@ -1352,11 +1413,16 @@ static long do_poll(struct sched_poll *sched_poll)
long vcpu_yield(void)
{
struct vcpu * v=current;
- spinlock_t *lock = unit_schedule_lock_irq(v->sched_unit);
+ spinlock_t *lock;
+
+ rcu_read_lock(&sched_res_rculock);
+ lock = unit_schedule_lock_irq(v->sched_unit);
sched_yield(vcpu_scheduler(v), v->sched_unit);
unit_schedule_unlock_irq(lock, v->sched_unit);
+ rcu_read_unlock(&sched_res_rculock);
+
SCHED_STAT_CRANK(vcpu_yield);
TRACE_2D(TRC_SCHED_YIELD, current->domain->domain_id, current->vcpu_id);
@@ -1453,6 +1519,8 @@ int vcpu_temporary_affinity(struct vcpu *v, unsigned int cpu, uint8_t reason)
int ret = -EINVAL;
bool migrate;
+ rcu_read_lock(&sched_res_rculock);
+
lock = unit_schedule_lock_irq(unit);
if ( cpu == NR_CPUS )
@@ -1492,6 +1560,8 @@ int vcpu_temporary_affinity(struct vcpu *v, unsigned int cpu, uint8_t reason)
if ( migrate )
sched_unit_migrate_finish(unit);
+ rcu_read_unlock(&sched_res_rculock);
+
return ret;
}
@@ -1703,9 +1773,13 @@ long sched_adjust(struct domain *d, struct xen_domctl_scheduler_op *op)
/* NB: the pluggable scheduler code needs to take care
* of locking by itself. */
+ rcu_read_lock(&sched_res_rculock);
+
if ( (ret = sched_adjust_dom(dom_scheduler(d), d, op)) == 0 )
TRACE_1D(TRC_SCHED_ADJDOM, d->domain_id);
+ rcu_read_unlock(&sched_res_rculock);
+
return ret;
}
@@ -1726,9 +1800,13 @@ long sched_adjust_global(struct xen_sysctl_scheduler_op *op)
if ( pool == NULL )
return -ESRCH;
+ rcu_read_lock(&sched_res_rculock);
+
rc = ((op->sched_id == pool->sched->sched_id)
? sched_adjust_cpupool(pool->sched, op) : -EINVAL);
+ rcu_read_unlock(&sched_res_rculock);
+
cpupool_put(pool);
return rc;
@@ -1948,7 +2026,11 @@ static void unit_context_saved(struct sched_resource *sd)
void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
{
struct sched_unit *next = vnext->sched_unit;
- struct sched_resource *sd = get_sched_res(smp_processor_id());
+ struct sched_resource *sd;
+
+ rcu_read_lock(&sched_res_rculock);
+
+ sd = get_sched_res(smp_processor_id());
if ( atomic_read(&next->rendezvous_out_cnt) )
{
@@ -1975,6 +2057,8 @@ void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
if ( is_idle_vcpu(vprev) && vprev != vnext )
vprev->sched_unit = sd->sched_unit_idle;
+
+ rcu_read_unlock(&sched_res_rculock);
}
static void sched_context_switch(struct vcpu *vprev, struct vcpu *vnext,
@@ -1992,6 +2076,8 @@ static void sched_context_switch(struct vcpu *vprev, struct vcpu *vnext,
vnext->sched_unit =
get_sched_res(smp_processor_id())->sched_unit_idle;
+ rcu_read_unlock(&sched_res_rculock);
+
trace_continue_running(vnext);
return continue_running(vprev);
}
@@ -2005,6 +2091,8 @@ static void sched_context_switch(struct vcpu *vprev, struct vcpu *vnext,
vcpu_periodic_timer_work(vnext);
+ rcu_read_unlock(&sched_res_rculock);
+
context_switch(vprev, vnext);
}
@@ -2152,6 +2240,8 @@ static void sched_slave(void)
ASSERT_NOT_IN_ATOMIC();
+ rcu_read_lock(&sched_res_rculock);
+
lock = pcpu_schedule_lock_irq(cpu);
now = NOW();
@@ -2175,6 +2265,8 @@ static void sched_slave(void)
{
pcpu_schedule_unlock_irq(lock, cpu);
+ rcu_read_unlock(&sched_res_rculock);
+
/* Check for failed forced context switch. */
if ( do_softirq )
raise_softirq(SCHEDULE_SOFTIRQ);
@@ -2205,13 +2297,16 @@ static void schedule(void)
struct sched_resource *sd;
spinlock_t *lock;
int cpu = smp_processor_id();
- unsigned int gran = get_sched_res(cpu)->granularity;
+ unsigned int gran;
ASSERT_NOT_IN_ATOMIC();
SCHED_STAT_CRANK(sched_run);
+ rcu_read_lock(&sched_res_rculock);
+
sd = get_sched_res(cpu);
+ gran = sd->granularity;
lock = pcpu_schedule_lock_irq(cpu);
@@ -2223,6 +2318,8 @@ static void schedule(void)
*/
pcpu_schedule_unlock_irq(lock, cpu);
+ rcu_read_unlock(&sched_res_rculock);
+
raise_softirq(SCHEDULE_SOFTIRQ);
return sched_slave();
}
@@ -2332,14 +2429,27 @@ static int cpu_schedule_up(unsigned int cpu)
return 0;
}
+static void sched_res_free(struct rcu_head *head)
+{
+ struct sched_resource *sd = container_of(head, struct sched_resource, rcu);
+
+ xfree(sd);
+}
+
static void cpu_schedule_down(unsigned int cpu)
{
- struct sched_resource *sd = get_sched_res(cpu);
+ struct sched_resource *sd;
+
+ rcu_read_lock(&sched_res_rculock);
+
+ sd = get_sched_res(cpu);
kill_timer(&sd->s_timer);
set_sched_res(cpu, NULL);
- xfree(sd);
+ call_rcu(&sd->rcu, sched_res_free);
+
+ rcu_read_unlock(&sched_res_rculock);
}
void sched_rm_cpu(unsigned int cpu)
@@ -2359,6 +2469,8 @@ static int cpu_schedule_callback(
unsigned int cpu = (unsigned long)hcpu;
int rc = 0;
+ rcu_read_lock(&sched_res_rculock);
+
/*
* From the scheduler perspective, bringing up a pCPU requires
* allocating and initializing the per-pCPU scheduler specific data,
@@ -2405,6 +2517,8 @@ static int cpu_schedule_callback(
break;
}
+ rcu_read_unlock(&sched_res_rculock);
+
return !rc ? NOTIFY_DONE : notifier_from_errno(rc);
}
@@ -2494,8 +2608,13 @@ void __init scheduler_init(void)
idle_domain->max_vcpus = nr_cpu_ids;
if ( vcpu_create(idle_domain, 0) == NULL )
BUG();
+
+ rcu_read_lock(&sched_res_rculock);
+
get_sched_res(0)->curr = idle_vcpu[0]->sched_unit;
get_sched_res(0)->sched_unit_idle = idle_vcpu[0]->sched_unit;
+
+ rcu_read_unlock(&sched_res_rculock);
}
/*
@@ -2508,9 +2627,14 @@ int schedule_cpu_add(unsigned int cpu, struct cpupool *c)
struct vcpu *idle;
void *ppriv, *vpriv;
struct scheduler *new_ops = c->sched;
- struct sched_resource *sd = get_sched_res(cpu);
+ struct sched_resource *sd;
spinlock_t *old_lock, *new_lock;
unsigned long flags;
+ int ret = 0;
+
+ rcu_read_lock(&sched_res_rculock);
+
+ sd = get_sched_res(cpu);
ASSERT(cpumask_test_cpu(cpu, &cpupool_free_cpus));
ASSERT(!cpumask_test_cpu(cpu, c->cpu_valid));
@@ -2530,13 +2654,18 @@ int schedule_cpu_add(unsigned int cpu, struct cpupool *c)
idle = idle_vcpu[cpu];
ppriv = sched_alloc_pdata(new_ops, cpu);
if ( IS_ERR(ppriv) )
- return PTR_ERR(ppriv);
+ {
+ ret = PTR_ERR(ppriv);
+ goto out;
+ }
+
vpriv = sched_alloc_vdata(new_ops, idle->sched_unit,
idle->domain->sched_priv);
if ( vpriv == NULL )
{
sched_free_pdata(new_ops, ppriv, cpu);
- return -ENOMEM;
+ ret = -ENOMEM;
+ goto out;
}
/*
@@ -2575,7 +2704,10 @@ int schedule_cpu_add(unsigned int cpu, struct cpupool *c)
/* The cpu is added to a pool, trigger it to go pick up some work */
cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
- return 0;
+out:
+ rcu_read_unlock(&sched_res_rculock);
+
+ return ret;
}
/*
@@ -2588,11 +2720,16 @@ int schedule_cpu_rm(unsigned int cpu)
{
struct vcpu *idle;
void *ppriv_old, *vpriv_old;
- struct sched_resource *sd = get_sched_res(cpu);
- struct scheduler *old_ops = sd->scheduler;
+ struct sched_resource *sd;
+ struct scheduler *old_ops;
spinlock_t *old_lock;
unsigned long flags;
+ rcu_read_lock(&sched_res_rculock);
+
+ sd = get_sched_res(cpu);
+ old_ops = sd->scheduler;
+
ASSERT(sd->cpupool != NULL);
ASSERT(cpumask_test_cpu(cpu, &cpupool_free_cpus));
ASSERT(!cpumask_test_cpu(cpu, sd->cpupool->cpu_valid));
@@ -2625,6 +2762,8 @@ int schedule_cpu_rm(unsigned int cpu)
sd->granularity = 1;
sd->cpupool = NULL;
+ rcu_read_unlock(&sched_res_rculock);
+
return 0;
}
@@ -2673,6 +2812,8 @@ void schedule_dump(struct cpupool *c)
/* Locking, if necessary, must be handled withing each scheduler */
+ rcu_read_lock(&sched_res_rculock);
+
if ( c != NULL )
{
sched = c->sched;
@@ -2692,6 +2833,8 @@ void schedule_dump(struct cpupool *c)
for_each_cpu (i, cpus)
sched_dump_cpu_state(sched, i);
}
+
+ rcu_read_unlock(&sched_res_rculock);
}
void sched_tick_suspend(void)
@@ -2699,10 +2842,14 @@ void sched_tick_suspend(void)
struct scheduler *sched;
unsigned int cpu = smp_processor_id();
+ rcu_read_lock(&sched_res_rculock);
+
sched = get_sched_res(cpu)->scheduler;
sched_do_tick_suspend(sched, cpu);
rcu_idle_enter(cpu);
rcu_idle_timer_start();
+
+ rcu_read_unlock(&sched_res_rculock);
}
void sched_tick_resume(void)
@@ -2710,10 +2857,14 @@ void sched_tick_resume(void)
struct scheduler *sched;
unsigned int cpu = smp_processor_id();
+ rcu_read_lock(&sched_res_rculock);
+
rcu_idle_timer_stop();
rcu_idle_exit(cpu);
sched = get_sched_res(cpu)->scheduler;
sched_do_tick_resume(sched, cpu);
+
+ rcu_read_unlock(&sched_res_rculock);
}
void wait(void)
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index cb58bad0ff..f10ed768b0 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -10,6 +10,7 @@
#include <xen/percpu.h>
#include <xen/err.h>
+#include <xen/rcupdate.h>
/* A global pointer to the initial cpupool (POOL0). */
extern struct cpupool *cpupool0;
@@ -59,20 +60,22 @@ struct sched_resource {
unsigned int master_cpu;
unsigned int granularity;
const cpumask_t *cpus; /* cpus covered by this struct */
+ struct rcu_head rcu;
};
#define curr_on_cpu(c) (get_sched_res(c)->curr)
DECLARE_PER_CPU(struct sched_resource *, sched_res);
+extern rcu_read_lock_t sched_res_rculock;
static inline struct sched_resource *get_sched_res(unsigned int cpu)
{
- return per_cpu(sched_res, cpu);
+ return rcu_dereference(per_cpu(sched_res, cpu));
}
static inline void set_sched_res(unsigned int cpu, struct sched_resource *res)
{
- per_cpu(sched_res, cpu) = res;
+ rcu_assign_pointer(per_cpu(sched_res, cpu), res);
}
static inline bool is_idle_unit(const struct sched_unit *unit)
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 43/47] xen/sched: support multiple cpus per scheduling resource
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (41 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 42/47] xen/sched: protect scheduling resource via rcu Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-24 13:49 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 44/47] xen/sched: support differing granularity in schedule_cpu_[add/rm]() Juergen Gross
` (5 subsequent siblings)
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
Prepare supporting multiple cpus per scheduling resource by allocating
the cpumask per resource dynamically.
Modify sched_res_mask to have only one bit per scheduling resource set.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V1: new patch (carved out from other patch)
---
xen/common/schedule.c | 16 ++++++++++++++--
xen/include/xen/sched-if.h | 4 ++--
2 files changed, 16 insertions(+), 4 deletions(-)
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index c2e5a9220d..882b3baf42 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -59,7 +59,7 @@ integer_param("sched_ratelimit_us", sched_ratelimit_us);
enum sched_gran __read_mostly opt_sched_granularity = SCHED_GRAN_cpu;
unsigned int __read_mostly sched_granularity = 1;
bool __read_mostly sched_disable_smt_switching;
-const cpumask_t *sched_res_mask = &cpumask_all;
+cpumask_var_t sched_res_mask;
/* Common lock for free cpus. */
static DEFINE_SPINLOCK(sched_free_cpu_lock);
@@ -2388,8 +2388,14 @@ static int cpu_schedule_up(unsigned int cpu)
sd = xzalloc(struct sched_resource);
if ( sd == NULL )
return -ENOMEM;
+ if ( !zalloc_cpumask_var(&sd->cpus) )
+ {
+ xfree(sd);
+ return -ENOMEM;
+ }
+
sd->master_cpu = cpu;
- sd->cpus = cpumask_of(cpu);
+ cpumask_copy(sd->cpus, cpumask_of(cpu));
set_sched_res(cpu, sd);
sd->scheduler = &sched_idle_ops;
@@ -2401,6 +2407,8 @@ static int cpu_schedule_up(unsigned int cpu)
/* We start with cpu granularity. */
sd->granularity = 1;
+ cpumask_set_cpu(cpu, sched_res_mask);
+
/* Boot CPU is dealt with later in scheduler_init(). */
if ( cpu == 0 )
return 0;
@@ -2433,6 +2441,7 @@ static void sched_res_free(struct rcu_head *head)
{
struct sched_resource *sd = container_of(head, struct sched_resource, rcu);
+ free_cpumask_var(sd->cpus);
xfree(sd);
}
@@ -2581,6 +2590,9 @@ void __init scheduler_init(void)
printk("Using '%s' (%s)\n", ops.name, ops.opt_name);
}
+ if ( !zalloc_cpumask_var(&sched_res_mask) )
+ BUG();
+
if ( cpu_schedule_up(0) )
BUG();
register_cpu_notifier(&cpu_schedule_nfb);
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index f10ed768b0..1770b9bca1 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -24,7 +24,7 @@ extern cpumask_t cpupool_free_cpus;
extern int sched_ratelimit_us;
/* Scheduling resource mask. */
-extern const cpumask_t *sched_res_mask;
+extern cpumask_var_t sched_res_mask;
/* Number of vcpus per struct sched_unit. */
enum sched_gran {
@@ -59,7 +59,7 @@ struct sched_resource {
/* Cpu with lowest id in scheduling resource. */
unsigned int master_cpu;
unsigned int granularity;
- const cpumask_t *cpus; /* cpus covered by this struct */
+ cpumask_var_t cpus; /* cpus covered by this struct */
struct rcu_head rcu;
};
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 44/47] xen/sched: support differing granularity in schedule_cpu_[add/rm]()
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (42 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 43/47] xen/sched: support multiple cpus per scheduling resource Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 45/47] xen/sched: support core scheduling for moving cpus to/from cpupools Juergen Gross
` (4 subsequent siblings)
48 siblings, 0 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel; +Cc: Juergen Gross, George Dunlap, Dario Faggioli
With core scheduling active schedule_cpu_[add/rm]() has to cope with
different scheduling granularity: a cpu not in any cpupool is subject
to granularity 1 (cpu scheduling), while a cpu in a cpupool might be
in a scheduling resource with more than one cpu.
Handle that by having arrays of old/new pdata and vdata and loop over
those where appropriate.
Additionally the scheduling resource(s) must either be merged or
split.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
xen/common/cpupool.c | 18 ++--
xen/common/schedule.c | 226 +++++++++++++++++++++++++++++++++++++++++++-------
2 files changed, 204 insertions(+), 40 deletions(-)
diff --git a/xen/common/cpupool.c b/xen/common/cpupool.c
index f53ceec3ab..ada3a7e824 100644
--- a/xen/common/cpupool.c
+++ b/xen/common/cpupool.c
@@ -531,6 +531,7 @@ static void cpupool_cpu_remove(unsigned int cpu)
ret = cpupool_unassign_cpu_finish(cpupool0);
BUG_ON(ret);
}
+ cpumask_clear_cpu(cpu, &cpupool_free_cpus);
}
/*
@@ -580,20 +581,19 @@ static void cpupool_cpu_remove_forced(unsigned int cpu)
struct cpupool **c;
int ret;
- if ( cpumask_test_cpu(cpu, &cpupool_free_cpus) )
- cpumask_clear_cpu(cpu, &cpupool_free_cpus);
- else
+ for_each_cpupool ( c )
{
- for_each_cpupool(c)
+ if ( cpumask_test_cpu(cpu, (*c)->cpu_valid) )
{
- if ( cpumask_test_cpu(cpu, (*c)->cpu_valid) )
- {
- ret = cpupool_unassign_cpu(*c, cpu);
- BUG_ON(ret);
- }
+ ret = cpupool_unassign_cpu_start(*c, cpu);
+ BUG_ON(ret);
+ ret = cpupool_unassign_cpu_finish(*c);
+ BUG_ON(ret);
}
}
+ cpumask_clear_cpu(cpu, &cpupool_free_cpus);
+
rcu_read_lock(&sched_res_rculock);
sched_rm_cpu(cpu);
rcu_read_unlock(&sched_res_rculock);
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 882b3baf42..4d56cd907f 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -404,27 +404,30 @@ static void sched_unit_add_vcpu(struct sched_unit *unit, struct vcpu *v)
unit->runstate_cnt[v->runstate.state]++;
}
-static struct sched_unit *sched_alloc_unit(struct vcpu *v)
+static struct sched_unit *sched_alloc_unit_mem(void)
{
- struct sched_unit *unit, **prev_unit;
- struct domain *d = v->domain;
- unsigned int gran = d->cpupool ? d->cpupool->granularity : 1;
+ struct sched_unit *unit;
- for_each_sched_unit ( d, unit )
- if ( unit->vcpu_list->vcpu_id / gran == v->vcpu_id / gran )
- break;
+ unit = xzalloc(struct sched_unit);
+ if ( !unit )
+ return NULL;
- if ( unit )
+ if ( !zalloc_cpumask_var(&unit->cpu_hard_affinity) ||
+ !zalloc_cpumask_var(&unit->cpu_hard_affinity_saved) ||
+ !zalloc_cpumask_var(&unit->cpu_soft_affinity) )
{
- sched_unit_add_vcpu(unit, v);
- return unit;
+ sched_free_unit_mem(unit);
+ unit = NULL;
}
- if ( (unit = xzalloc(struct sched_unit)) == NULL )
- return NULL;
+ return unit;
+}
+
+static void sched_domain_insert_unit(struct sched_unit *unit, struct domain *d)
+{
+ struct sched_unit **prev_unit;
unit->domain = d;
- sched_unit_add_vcpu(unit, v);
for ( prev_unit = &d->sched_unit_list; *prev_unit;
prev_unit = &(*prev_unit)->next_in_list )
@@ -434,17 +437,31 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
unit->next_in_list = *prev_unit;
*prev_unit = unit;
+}
- if ( !zalloc_cpumask_var(&unit->cpu_hard_affinity) ||
- !zalloc_cpumask_var(&unit->cpu_hard_affinity_saved) ||
- !zalloc_cpumask_var(&unit->cpu_soft_affinity) )
- goto fail;
+static struct sched_unit *sched_alloc_unit(struct vcpu *v)
+{
+ struct sched_unit *unit;
+ struct domain *d = v->domain;
+ unsigned int gran = d->cpupool ? d->cpupool->granularity : 1;
- return unit;
+ for_each_sched_unit ( d, unit )
+ if ( unit->vcpu_list->vcpu_id / gran == v->vcpu_id / gran )
+ break;
- fail:
- sched_free_unit(unit, v);
- return NULL;
+ if ( unit )
+ {
+ sched_unit_add_vcpu(unit, v);
+ return unit;
+ }
+
+ if ( (unit = sched_alloc_unit_mem()) == NULL )
+ return NULL;
+
+ sched_unit_add_vcpu(unit, v);
+ sched_domain_insert_unit(unit, d);
+
+ return unit;
}
static unsigned int sched_select_initial_cpu(const struct vcpu *v)
@@ -2381,18 +2398,28 @@ static void poll_timer_fn(void *data)
vcpu_unblock(v);
}
-static int cpu_schedule_up(unsigned int cpu)
+static struct sched_resource *sched_alloc_res(void)
{
struct sched_resource *sd;
sd = xzalloc(struct sched_resource);
if ( sd == NULL )
- return -ENOMEM;
+ return NULL;
if ( !zalloc_cpumask_var(&sd->cpus) )
{
xfree(sd);
- return -ENOMEM;
+ return NULL;
}
+ return sd;
+}
+
+static int cpu_schedule_up(unsigned int cpu)
+{
+ struct sched_resource *sd;
+
+ sd = sched_alloc_res();
+ if ( sd == NULL )
+ return -ENOMEM;
sd->master_cpu = cpu;
cpumask_copy(sd->cpus, cpumask_of(cpu));
@@ -2442,6 +2469,8 @@ static void sched_res_free(struct rcu_head *head)
struct sched_resource *sd = container_of(head, struct sched_resource, rcu);
free_cpumask_var(sd->cpus);
+ if ( sd->sched_unit_idle )
+ sched_free_unit_mem(sd->sched_unit_idle);
xfree(sd);
}
@@ -2456,6 +2485,8 @@ static void cpu_schedule_down(unsigned int cpu)
kill_timer(&sd->s_timer);
set_sched_res(cpu, NULL);
+ /* Keep idle unit. */
+ sd->sched_unit_idle = NULL;
call_rcu(&sd->rcu, sched_res_free);
rcu_read_unlock(&sched_res_rculock);
@@ -2535,6 +2566,30 @@ static struct notifier_block cpu_schedule_nfb = {
.notifier_call = cpu_schedule_callback
};
+static const cpumask_t *sched_get_opt_cpumask(enum sched_gran opt,
+ unsigned int cpu)
+{
+ const cpumask_t *mask;
+
+ switch ( opt )
+ {
+ case SCHED_GRAN_cpu:
+ mask = cpumask_of(cpu);
+ break;
+ case SCHED_GRAN_core:
+ mask = per_cpu(cpu_sibling_mask, cpu);
+ break;
+ case SCHED_GRAN_socket:
+ mask = per_cpu(cpu_core_mask, cpu);
+ break;
+ default:
+ ASSERT_UNREACHABLE();
+ return NULL;
+ }
+
+ return mask;
+}
+
/* Initialise the data structures. */
void __init scheduler_init(void)
{
@@ -2693,6 +2748,46 @@ int schedule_cpu_add(unsigned int cpu, struct cpupool *c)
*/
old_lock = pcpu_schedule_lock_irqsave(cpu, &flags);
+ if ( c->granularity > 1 )
+ {
+ const cpumask_t *mask;
+ unsigned int cpu_iter, idx = 0;
+ struct sched_unit *old_unit, *master_unit;
+ struct sched_resource *sd_old;
+
+ /*
+ * We need to merge multiple idle_vcpu units and sched_resource structs
+ * into one. As the free cpus all share the same lock we are fine doing
+ * that now. The worst which could happen would be someone waiting for
+ * the lock, thus dereferencing sched_res->schedule_lock. This is the
+ * reason we are freeing struct sched_res via call_rcu() to avoid the
+ * lock pointer suddenly disappearing.
+ */
+ mask = sched_get_opt_cpumask(c->opt_granularity, cpu);
+ master_unit = idle_vcpu[cpu]->sched_unit;
+
+ for_each_cpu ( cpu_iter, mask )
+ {
+ if ( idx )
+ cpumask_clear_cpu(cpu_iter, sched_res_mask);
+
+ per_cpu(sched_res_idx, cpu_iter) = idx++;
+
+ if ( cpu == cpu_iter )
+ continue;
+
+ old_unit = idle_vcpu[cpu_iter]->sched_unit;
+ sd_old = get_sched_res(cpu_iter);
+ kill_timer(&sd_old->s_timer);
+ idle_vcpu[cpu_iter]->sched_unit = master_unit;
+ master_unit->runstate_cnt[RUNSTATE_running]++;
+ set_sched_res(cpu_iter, sd);
+ cpumask_set_cpu(cpu_iter, sd->cpus);
+
+ call_rcu(&sd_old->rcu, sched_res_free);
+ }
+ }
+
new_lock = sched_switch_sched(new_ops, cpu, ppriv, vpriv);
sd->scheduler = new_ops;
@@ -2730,33 +2825,100 @@ out:
*/
int schedule_cpu_rm(unsigned int cpu)
{
- struct vcpu *idle;
void *ppriv_old, *vpriv_old;
- struct sched_resource *sd;
+ struct sched_resource *sd, **sd_new = NULL;
+ struct sched_unit *unit;
struct scheduler *old_ops;
spinlock_t *old_lock;
unsigned long flags;
+ int idx, ret = -ENOMEM;
+ unsigned int cpu_iter;
rcu_read_lock(&sched_res_rculock);
sd = get_sched_res(cpu);
old_ops = sd->scheduler;
+ if ( sd->granularity > 1 )
+ {
+ sd_new = xmalloc_array(struct sched_resource *, sd->granularity - 1);
+ if ( !sd_new )
+ goto out;
+ for ( idx = 0; idx < sd->granularity - 1; idx++ )
+ {
+ sd_new[idx] = sched_alloc_res();
+ if ( sd_new[idx] )
+ {
+ sd_new[idx]->sched_unit_idle = sched_alloc_unit_mem();
+ if ( !sd_new[idx]->sched_unit_idle )
+ {
+ sched_res_free(&sd_new[idx]->rcu);
+ sd_new[idx] = NULL;
+ }
+ }
+ if ( !sd_new[idx] )
+ {
+ for ( idx--; idx >= 0; idx-- )
+ sched_res_free(&sd_new[idx]->rcu);
+ goto out;
+ }
+ sd_new[idx]->curr = sd_new[idx]->sched_unit_idle;
+ sd_new[idx]->scheduler = &sched_idle_ops;
+ sd_new[idx]->granularity = 1;
+
+ /* We want the lock not to change when replacing the resource. */
+ sd_new[idx]->schedule_lock = sd->schedule_lock;
+ }
+ }
+
+ ret = 0;
ASSERT(sd->cpupool != NULL);
ASSERT(cpumask_test_cpu(cpu, &cpupool_free_cpus));
ASSERT(!cpumask_test_cpu(cpu, sd->cpupool->cpu_valid));
- idle = idle_vcpu[cpu];
-
sched_do_tick_suspend(old_ops, cpu);
/* See comment in schedule_cpu_add() regarding lock switching. */
old_lock = pcpu_schedule_lock_irqsave(cpu, &flags);
- vpriv_old = idle->sched_unit->priv;
+ vpriv_old = idle_vcpu[cpu]->sched_unit->priv;
ppriv_old = sd->sched_priv;
- idle->sched_unit->priv = NULL;
+ idx = 0;
+ for_each_cpu ( cpu_iter, sd->cpus )
+ {
+ per_cpu(sched_res_idx, cpu_iter) = 0;
+ if ( cpu_iter == cpu )
+ {
+ idle_vcpu[cpu_iter]->sched_unit->priv = NULL;
+ }
+ else
+ {
+ /* Initialize unit. */
+ unit = sd_new[idx]->sched_unit_idle;
+ unit->res = sd_new[idx];
+ unit->is_running = true;
+ sched_unit_add_vcpu(unit, idle_vcpu[cpu_iter]);
+ sched_domain_insert_unit(unit, idle_vcpu[cpu_iter]->domain);
+
+ /* Adjust cpu masks of resources (old and new). */
+ cpumask_clear_cpu(cpu_iter, sd->cpus);
+ cpumask_set_cpu(cpu_iter, sd_new[idx]->cpus);
+
+ /* Init timer. */
+ init_timer(&sd_new[idx]->s_timer, s_timer_fn, NULL, cpu_iter);
+
+ /* Last resource initializations and insert resource pointer. */
+ sd_new[idx]->master_cpu = cpu_iter;
+ set_sched_res(cpu_iter, sd_new[idx]);
+
+ /* Last action: set the new lock pointer. */
+ smp_mb();
+ sd_new[idx]->schedule_lock = &sched_free_cpu_lock;
+
+ idx++;
+ }
+ }
sd->scheduler = &sched_idle_ops;
sd->sched_priv = NULL;
@@ -2774,9 +2936,11 @@ int schedule_cpu_rm(unsigned int cpu)
sd->granularity = 1;
sd->cpupool = NULL;
+out:
rcu_read_unlock(&sched_res_rculock);
+ xfree(sd_new);
- return 0;
+ return ret;
}
struct scheduler *scheduler_get_default(void)
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 45/47] xen/sched: support core scheduling for moving cpus to/from cpupools
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (43 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 44/47] xen/sched: support differing granularity in schedule_cpu_[add/rm]() Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 46/47] xen/sched: disable scheduling when entering ACPI deep sleep states Juergen Gross
` (3 subsequent siblings)
48 siblings, 0 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Tim Deegan, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Dario Faggioli, Julien Grall, Jan Beulich
With core scheduling active it is necessary to move multiple cpus at
the same time to or from a cpupool in order to avoid split scheduling
resources in between.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V1: new patch
---
xen/common/cpupool.c | 100 +++++++++++++++++++++++++++++++++------------
xen/common/schedule.c | 3 +-
xen/include/xen/sched-if.h | 1 +
3 files changed, 76 insertions(+), 28 deletions(-)
diff --git a/xen/common/cpupool.c b/xen/common/cpupool.c
index ada3a7e824..7f173f5099 100644
--- a/xen/common/cpupool.c
+++ b/xen/common/cpupool.c
@@ -263,23 +263,30 @@ static int cpupool_assign_cpu_locked(struct cpupool *c, unsigned int cpu)
{
int ret;
struct domain *d;
+ const cpumask_t *cpus;
+
+ cpus = sched_get_opt_cpumask(c->opt_granularity, cpu);
if ( (cpupool_moving_cpu == cpu) && (c != cpupool_cpu_moving) )
return -EADDRNOTAVAIL;
- ret = schedule_cpu_add(cpu, c);
+ ret = schedule_cpu_add(cpumask_first(cpus), c);
if ( ret )
return ret;
- cpumask_clear_cpu(cpu, &cpupool_free_cpus);
+ rcu_read_lock(&sched_res_rculock);
+
+ cpumask_andnot(&cpupool_free_cpus, &cpupool_free_cpus, cpus);
if (cpupool_moving_cpu == cpu)
{
cpupool_moving_cpu = -1;
cpupool_put(cpupool_cpu_moving);
cpupool_cpu_moving = NULL;
}
- cpumask_set_cpu(cpu, c->cpu_valid);
+ cpumask_or(c->cpu_valid, c->cpu_valid, cpus);
cpumask_and(c->res_valid, c->cpu_valid, sched_res_mask);
+ rcu_read_unlock(&sched_res_rculock);
+
rcu_read_lock(&domlist_read_lock);
for_each_domain_in_cpupool(d, c)
{
@@ -293,6 +300,7 @@ static int cpupool_assign_cpu_locked(struct cpupool *c, unsigned int cpu)
static int cpupool_unassign_cpu_finish(struct cpupool *c)
{
int cpu = cpupool_moving_cpu;
+ const cpumask_t *cpus;
struct domain *d;
int ret;
@@ -305,7 +313,10 @@ static int cpupool_unassign_cpu_finish(struct cpupool *c)
*/
rcu_read_lock(&domlist_read_lock);
ret = cpu_disable_scheduler(cpu);
- cpumask_set_cpu(cpu, &cpupool_free_cpus);
+
+ rcu_read_lock(&sched_res_rculock);
+ cpus = get_sched_res(cpu)->cpus;
+ cpumask_or(&cpupool_free_cpus, &cpupool_free_cpus, cpus);
/*
* cpu_disable_scheduler() returning an error doesn't require resetting
@@ -318,7 +329,7 @@ static int cpupool_unassign_cpu_finish(struct cpupool *c)
{
ret = schedule_cpu_rm(cpu);
if ( ret )
- cpumask_clear_cpu(cpu, &cpupool_free_cpus);
+ cpumask_andnot(&cpupool_free_cpus, &cpupool_free_cpus, cpus);
else
{
cpupool_moving_cpu = -1;
@@ -326,6 +337,7 @@ static int cpupool_unassign_cpu_finish(struct cpupool *c)
cpupool_cpu_moving = NULL;
}
}
+ rcu_read_unlock(&sched_res_rculock);
for_each_domain_in_cpupool(d, c)
{
@@ -340,6 +352,7 @@ static int cpupool_unassign_cpu_start(struct cpupool *c, unsigned int cpu)
{
int ret;
struct domain *d;
+ const cpumask_t *cpus;
spin_lock(&cpupool_lock);
ret = -EADDRNOTAVAIL;
@@ -348,7 +361,11 @@ static int cpupool_unassign_cpu_start(struct cpupool *c, unsigned int cpu)
goto out;
ret = 0;
- if ( (c->n_dom > 0) && (cpumask_weight(c->cpu_valid) == 1) &&
+ rcu_read_lock(&sched_res_rculock);
+ cpus = get_sched_res(cpu)->cpus;
+
+ if ( (c->n_dom > 0) &&
+ (cpumask_weight(c->cpu_valid) == cpumask_weight(cpus)) &&
(cpu != cpupool_moving_cpu) )
{
rcu_read_lock(&domlist_read_lock);
@@ -370,9 +387,10 @@ static int cpupool_unassign_cpu_start(struct cpupool *c, unsigned int cpu)
cpupool_moving_cpu = cpu;
atomic_inc(&c->refcnt);
cpupool_cpu_moving = c;
- cpumask_clear_cpu(cpu, c->cpu_valid);
+ cpumask_andnot(c->cpu_valid, c->cpu_valid, cpus);
cpumask_and(c->res_valid, c->cpu_valid, sched_res_mask);
+ rcu_read_unlock(&domlist_read_lock);
out:
spin_unlock(&cpupool_lock);
@@ -412,11 +430,13 @@ static int cpupool_unassign_cpu(struct cpupool *c, unsigned int cpu)
{
int work_cpu;
int ret;
+ unsigned int master_cpu;
debugtrace_printk("cpupool_unassign_cpu(pool=%d,cpu=%d)\n",
c->cpupool_id, cpu);
- ret = cpupool_unassign_cpu_start(c, cpu);
+ master_cpu = sched_get_resource_cpu(cpu);
+ ret = cpupool_unassign_cpu_start(c, master_cpu);
if ( ret )
{
debugtrace_printk("cpupool_unassign_cpu(pool=%d,cpu=%d) ret %d\n",
@@ -424,12 +444,12 @@ static int cpupool_unassign_cpu(struct cpupool *c, unsigned int cpu)
return ret;
}
- work_cpu = smp_processor_id();
- if ( work_cpu == cpu )
+ work_cpu = sched_get_resource_cpu(smp_processor_id());
+ if ( work_cpu == master_cpu )
{
work_cpu = cpumask_first(cpupool0->cpu_valid);
- if ( work_cpu == cpu )
- work_cpu = cpumask_next(cpu, cpupool0->cpu_valid);
+ if ( work_cpu == master_cpu )
+ work_cpu = cpumask_last(cpupool0->cpu_valid);
}
return continue_hypercall_on_cpu(work_cpu, cpupool_unassign_cpu_helper, c);
}
@@ -495,6 +515,7 @@ void cpupool_rm_domain(struct domain *d)
static int cpupool_cpu_add(unsigned int cpu)
{
int ret = 0;
+ const cpumask_t *cpus;
spin_lock(&cpupool_lock);
cpumask_clear_cpu(cpu, &cpupool_locked_cpus);
@@ -508,7 +529,11 @@ static int cpupool_cpu_add(unsigned int cpu)
*/
rcu_read_lock(&sched_res_rculock);
get_sched_res(cpu)->cpupool = NULL;
- ret = cpupool_assign_cpu_locked(cpupool0, cpu);
+
+ cpus = sched_get_opt_cpumask(cpupool0->opt_granularity, cpu);
+ if ( cpumask_subset(cpus, &cpupool_free_cpus) )
+ ret = cpupool_assign_cpu_locked(cpupool0, cpu);
+
rcu_read_unlock(&sched_res_rculock);
spin_unlock(&cpupool_lock);
@@ -543,27 +568,33 @@ static void cpupool_cpu_remove(unsigned int cpu)
static int cpupool_cpu_remove_prologue(unsigned int cpu)
{
int ret = 0;
+ cpumask_t *cpus;
+ unsigned int master_cpu;
spin_lock(&cpupool_lock);
- if ( cpumask_test_cpu(cpu, &cpupool_locked_cpus) )
+ rcu_read_lock(&sched_res_rculock);
+ cpus = get_sched_res(cpu)->cpus;
+ master_cpu = sched_get_resource_cpu(cpu);
+ if ( cpumask_intersects(cpus, &cpupool_locked_cpus) )
ret = -EBUSY;
else
cpumask_set_cpu(cpu, &cpupool_locked_cpus);
+ rcu_read_unlock(&sched_res_rculock);
spin_unlock(&cpupool_lock);
if ( ret )
return ret;
- if ( cpumask_test_cpu(cpu, cpupool0->cpu_valid) )
+ if ( cpumask_test_cpu(master_cpu, cpupool0->cpu_valid) )
{
/* Cpupool0 is populated only after all cpus are up. */
ASSERT(system_state == SYS_STATE_active);
- ret = cpupool_unassign_cpu_start(cpupool0, cpu);
+ ret = cpupool_unassign_cpu_start(cpupool0, master_cpu);
}
- else if ( !cpumask_test_cpu(cpu, &cpupool_free_cpus) )
+ else if ( !cpumask_test_cpu(master_cpu, &cpupool_free_cpus) )
ret = -ENODEV;
return ret;
@@ -580,12 +611,13 @@ static void cpupool_cpu_remove_forced(unsigned int cpu)
{
struct cpupool **c;
int ret;
+ unsigned int master_cpu = sched_get_resource_cpu(cpu);
for_each_cpupool ( c )
{
- if ( cpumask_test_cpu(cpu, (*c)->cpu_valid) )
+ if ( cpumask_test_cpu(master_cpu, (*c)->cpu_valid) )
{
- ret = cpupool_unassign_cpu_start(*c, cpu);
+ ret = cpupool_unassign_cpu_start(*c, master_cpu);
BUG_ON(ret);
ret = cpupool_unassign_cpu_finish(*c);
BUG_ON(ret);
@@ -653,29 +685,45 @@ int cpupool_do_sysctl(struct xen_sysctl_cpupool_op *op)
case XEN_SYSCTL_CPUPOOL_OP_ADDCPU:
{
unsigned cpu;
+ const cpumask_t *cpus;
cpu = op->cpu;
debugtrace_printk("cpupool_assign_cpu(pool=%d,cpu=%d)\n",
op->cpupool_id, cpu);
+
spin_lock(&cpupool_lock);
+
+ c = cpupool_find_by_id(op->cpupool_id);
+ ret = -ENOENT;
+ if ( c == NULL )
+ goto addcpu_out;
if ( cpu == XEN_SYSCTL_CPUPOOL_PAR_ANY )
- cpu = cpumask_first(&cpupool_free_cpus);
+ {
+ for_each_cpu ( cpu, &cpupool_free_cpus )
+ {
+ cpus = sched_get_opt_cpumask(c->opt_granularity, cpu);
+ if ( cpumask_subset(cpus, &cpupool_free_cpus) )
+ break;
+ }
+ ret = -ENODEV;
+ if ( cpu >= nr_cpu_ids )
+ goto addcpu_out;
+ }
ret = -EINVAL;
if ( cpu >= nr_cpu_ids )
goto addcpu_out;
ret = -ENODEV;
- if ( !cpumask_test_cpu(cpu, &cpupool_free_cpus) ||
- cpumask_test_cpu(cpu, &cpupool_locked_cpus) )
- goto addcpu_out;
- c = cpupool_find_by_id(op->cpupool_id);
- ret = -ENOENT;
- if ( c == NULL )
+ cpus = sched_get_opt_cpumask(c->opt_granularity, cpu);
+ if ( !cpumask_subset(cpus, &cpupool_free_cpus) ||
+ cpumask_intersects(cpus, &cpupool_locked_cpus) )
goto addcpu_out;
ret = cpupool_assign_cpu_locked(c, cpu);
+
addcpu_out:
spin_unlock(&cpupool_lock);
debugtrace_printk("cpupool_assign_cpu(pool=%d,cpu=%d) ret %d\n",
op->cpupool_id, cpu, ret);
+
}
break;
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 4d56cd907f..4b2ccb7ddc 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -2566,8 +2566,7 @@ static struct notifier_block cpu_schedule_nfb = {
.notifier_call = cpu_schedule_callback
};
-static const cpumask_t *sched_get_opt_cpumask(enum sched_gran opt,
- unsigned int cpu)
+const cpumask_t *sched_get_opt_cpumask(enum sched_gran opt, unsigned int cpu)
{
const cpumask_t *mask;
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index 1770b9bca1..f1e8f44f62 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -625,5 +625,6 @@ affinity_balance_cpumask(const struct sched_unit *unit, int step,
}
void sched_rm_cpu(unsigned int cpu);
+const cpumask_t *sched_get_opt_cpumask(enum sched_gran opt, unsigned int cpu);
#endif /* __XEN_SCHED_IF_H__ */
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 46/47] xen/sched: disable scheduling when entering ACPI deep sleep states
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (44 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 45/47] xen/sched: support core scheduling for moving cpus to/from cpupools Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-25 16:02 ` Jan Beulich
2019-09-26 9:41 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 47/47] xen/sched: add scheduling granularity enum Juergen Gross
` (2 subsequent siblings)
48 siblings, 2 replies; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Tim Deegan, Julien Grall, Jan Beulich, Dario Faggioli,
Roger Pau Monné
When entering deep sleep states all domains are paused resulting in
all cpus only running idle vcpus. This enables us to stop scheduling
completely in order to avoid synchronization problems with core
scheduling when individual cpus are offlined.
Disabling the scheduler is done by replacing the softirq handler
with a dummy scheduling routine only enabling tasklets to run.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
V2: new patch
---
xen/arch/x86/acpi/power.c | 4 ++++
xen/common/schedule.c | 31 +++++++++++++++++++++++++++++--
xen/include/xen/sched.h | 2 ++
3 files changed, 35 insertions(+), 2 deletions(-)
diff --git a/xen/arch/x86/acpi/power.c b/xen/arch/x86/acpi/power.c
index e3954eeb75..8ce70baf01 100644
--- a/xen/arch/x86/acpi/power.c
+++ b/xen/arch/x86/acpi/power.c
@@ -145,12 +145,16 @@ static void freeze_domains(void)
for_each_domain ( d )
domain_pause(d);
rcu_read_unlock(&domlist_read_lock);
+
+ scheduler_disable();
}
static void thaw_domains(void)
{
struct domain *d;
+ scheduler_enable();
+
rcu_read_lock(&domlist_read_lock);
for_each_domain ( d )
{
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 4b2ccb7ddc..800d2405a7 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -87,6 +87,8 @@ extern const struct scheduler *__start_schedulers_array[], *__end_schedulers_arr
static struct scheduler __read_mostly ops;
+static bool scheduler_active;
+
static struct sched_resource *
sched_idle_res_pick(const struct scheduler *ops, const struct sched_unit *unit)
{
@@ -2241,6 +2243,13 @@ static struct sched_unit *sched_wait_rendezvous_in(struct sched_unit *prev,
cpu_relax();
*lock = pcpu_schedule_lock_irq(cpu);
+
+ if ( unlikely(!scheduler_active) )
+ {
+ ASSERT(is_idle_unit(prev));
+ atomic_set(&prev->next_task->rendezvous_out_cnt, 0);
+ prev->rendezvous_in_cnt = 0;
+ }
}
return prev->next_task;
@@ -2589,14 +2598,32 @@ const cpumask_t *sched_get_opt_cpumask(enum sched_gran opt, unsigned int cpu)
return mask;
}
+static void schedule_dummy(void)
+{
+ sched_tasklet_check_cpu(smp_processor_id());
+}
+
+void scheduler_disable(void)
+{
+ scheduler_active = false;
+ open_softirq(SCHEDULE_SOFTIRQ, schedule_dummy);
+ open_softirq(SCHED_SLAVE_SOFTIRQ, schedule_dummy);
+}
+
+void scheduler_enable(void)
+{
+ open_softirq(SCHEDULE_SOFTIRQ, schedule);
+ open_softirq(SCHED_SLAVE_SOFTIRQ, sched_slave);
+ scheduler_active = true;
+}
+
/* Initialise the data structures. */
void __init scheduler_init(void)
{
struct domain *idle_domain;
int i;
- open_softirq(SCHEDULE_SOFTIRQ, schedule);
- open_softirq(SCHED_SLAVE_SOFTIRQ, sched_slave);
+ scheduler_enable();
for ( i = 0; i < NUM_SCHEDULERS; i++)
{
diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h
index cc65922b88..bfd5517ac4 100644
--- a/xen/include/xen/sched.h
+++ b/xen/include/xen/sched.h
@@ -933,6 +933,8 @@ void restore_vcpu_affinity(struct domain *d);
void vcpu_runstate_get(struct vcpu *v, struct vcpu_runstate_info *runstate);
uint64_t get_cpu_idle_time(unsigned int cpu);
void sched_guest_idle(void (*idle) (void), unsigned int cpu);
+void scheduler_enable(void);
+void scheduler_disable(void);
/*
* Used by idle loop to decide whether there is work to do:
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* [Xen-devel] [PATCH v3 47/47] xen/sched: add scheduling granularity enum
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (45 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 46/47] xen/sched: disable scheduling when entering ACPI deep sleep states Juergen Gross
@ 2019-09-14 8:52 ` Juergen Gross
2019-09-26 9:46 ` Dario Faggioli
2019-09-20 16:14 ` [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Jan Beulich
2019-09-24 11:15 ` Sergey Dyasli
48 siblings, 1 reply; 161+ messages in thread
From: Juergen Gross @ 2019-09-14 8:52 UTC (permalink / raw)
To: xen-devel
Cc: Juergen Gross, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson,
Tim Deegan, Julien Grall, Jan Beulich, Dario Faggioli,
Roger Pau Monné
Add a scheduling granularity enum ("cpu", "core", "socket") for
specification of the scheduling granularity. Initially it is set to
"cpu", this can be modified by the new boot parameter (x86 only)
"sched-gran".
According to the selected granularity sched_granularity is set after
all cpus are online.
A test is added for all sched resources holding the same number of
cpus. Fall back to core- or cpu-scheduling in that case.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
RFC V2:
- fixed freeing of sched_res when merging cpus
- rename parameter to "sched-gran" (Jan Beulich)
- rename parameter option from "thread" to "cpu" (Jan Beulich)
V1:
- rename scheduler_smp_init() to scheduler_gran_init(), let it be called
by cpupool_init()
- avoid using literal cpu number 0 in scheduler_percpu_init() (Jan Beulich)
- style correction (Jan Beulich)
- fallback to smaller granularity instead of panic in case of
unbalanced cpu configuration
V2:
- style changes (Jan Beulich)
- introduce CONFIG_HAS_SCHED_GRANULARITY (Jan Beulich)
---
xen/arch/x86/Kconfig | 1 +
xen/common/Kconfig | 3 ++
xen/common/cpupool.c | 2 ++
xen/common/schedule.c | 78 ++++++++++++++++++++++++++++++++++++++++++++++
xen/include/xen/sched-if.h | 1 +
5 files changed, 85 insertions(+)
diff --git a/xen/arch/x86/Kconfig b/xen/arch/x86/Kconfig
index 288dc6c042..3f88adae97 100644
--- a/xen/arch/x86/Kconfig
+++ b/xen/arch/x86/Kconfig
@@ -22,6 +22,7 @@ config X86
select HAS_PASSTHROUGH
select HAS_PCI
select HAS_PDX
+ select HAS_SCHED_GRANULARITY
select HAS_UBSAN
select HAS_VPCI if !PV_SHIM_EXCLUSIVE && HVM
select NEEDS_LIBELF
diff --git a/xen/common/Kconfig b/xen/common/Kconfig
index 16829f6274..e9247871a8 100644
--- a/xen/common/Kconfig
+++ b/xen/common/Kconfig
@@ -63,6 +63,9 @@ config HAS_GDBSX
config HAS_IOPORTS
bool
+config HAS_SCHED_GRANULARITY
+ bool
+
config NEEDS_LIBELF
bool
diff --git a/xen/common/cpupool.c b/xen/common/cpupool.c
index 7f173f5099..4226f7ded8 100644
--- a/xen/common/cpupool.c
+++ b/xen/common/cpupool.c
@@ -866,6 +866,8 @@ static int __init cpupool_init(void)
unsigned int cpu;
int err;
+ scheduler_gran_init();
+
cpupool0 = cpupool_create(0, 0, &err);
BUG_ON(cpupool0 == NULL);
cpupool_put(cpupool0);
diff --git a/xen/common/schedule.c b/xen/common/schedule.c
index 800d2405a7..b940083a26 100644
--- a/xen/common/schedule.c
+++ b/xen/common/schedule.c
@@ -34,6 +34,7 @@
#include <xen/cpu.h>
#include <xen/preempt.h>
#include <xen/event.h>
+#include <xen/warning.h>
#include <public/sched.h>
#include <xsm/xsm.h>
#include <xen/err.h>
@@ -61,6 +62,23 @@ unsigned int __read_mostly sched_granularity = 1;
bool __read_mostly sched_disable_smt_switching;
cpumask_var_t sched_res_mask;
+#ifdef CONFIG_HAS_SCHED_GRANULARITY
+static int __init sched_select_granularity(const char *str)
+{
+ if ( strcmp("cpu", str) == 0 )
+ opt_sched_granularity = SCHED_GRAN_cpu;
+ else if ( strcmp("core", str) == 0 )
+ opt_sched_granularity = SCHED_GRAN_core;
+ else if ( strcmp("socket", str) == 0 )
+ opt_sched_granularity = SCHED_GRAN_socket;
+ else
+ return -EINVAL;
+
+ return 0;
+}
+custom_param("sched-gran", sched_select_granularity);
+#endif
+
/* Common lock for free cpus. */
static DEFINE_SPINLOCK(sched_free_cpu_lock);
@@ -2617,6 +2635,66 @@ void scheduler_enable(void)
scheduler_active = true;
}
+static unsigned int __init sched_check_granularity(void)
+{
+ unsigned int cpu;
+ unsigned int siblings, gran = 0;
+
+ if ( opt_sched_granularity == SCHED_GRAN_cpu )
+ return 1;
+
+ for_each_online_cpu ( cpu )
+ {
+ siblings = cpumask_weight(sched_get_opt_cpumask(opt_sched_granularity,
+ cpu));
+ if ( gran == 0 )
+ gran = siblings;
+ else if ( gran != siblings )
+ return 0;
+ }
+
+ sched_disable_smt_switching = true;
+
+ return gran;
+}
+
+/* Setup data for selected scheduler granularity. */
+void __init scheduler_gran_init(void)
+{
+ unsigned int gran = 0;
+ const char *fallback = NULL;
+
+ while ( gran == 0 )
+ {
+ gran = sched_check_granularity();
+
+ if ( gran == 0 )
+ {
+ switch ( opt_sched_granularity )
+ {
+ case SCHED_GRAN_core:
+ opt_sched_granularity = SCHED_GRAN_cpu;
+ fallback = "Asymmetric cpu configuration.\n"
+ "Falling back to sched-gran=cpu.\n";
+ break;
+ case SCHED_GRAN_socket:
+ opt_sched_granularity = SCHED_GRAN_core;
+ fallback = "Asymmetric cpu configuration.\n"
+ "Falling back to sched-gran=core.\n";
+ break;
+ default:
+ ASSERT_UNREACHABLE();
+ break;
+ }
+ }
+ }
+
+ if ( fallback )
+ warning_add(fallback);
+
+ sched_granularity = gran;
+}
+
/* Initialise the data structures. */
void __init scheduler_init(void)
{
diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
index f1e8f44f62..53158fe4ea 100644
--- a/xen/include/xen/sched-if.h
+++ b/xen/include/xen/sched-if.h
@@ -626,5 +626,6 @@ affinity_balance_cpumask(const struct sched_unit *unit, int step,
void sched_rm_cpu(unsigned int cpu);
const cpumask_t *sched_get_opt_cpumask(enum sched_gran opt, unsigned int cpu);
+void scheduler_gran_init(void);
#endif /* __XEN_SCHED_IF_H__ */
--
2.16.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource Juergen Gross
@ 2019-09-19 15:27 ` Jan Beulich
2019-09-24 11:41 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-19 15:27 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Dario Faggioli, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Roger Pau Monné
On 14.09.2019 10:52, Juergen Gross wrote:
> This prepares support of larger scheduling granularities, e.g. core
> scheduling.
>
> While at it move sched_has_urgent_vcpu() from include/asm-x86/cpuidle.h
> into sched.h removing the need for including sched-if.h in cpuidle.h.
> For that purpose remobe urgent_count from the scheduler private data
> and make it a plain percpu variable.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
Fundamentally
Reviewed-by: Jan Beulich <jbeulich@suse.com>
but a couple of remarks:
> @@ -643,7 +643,7 @@ static spinlock_t *
> a653_switch_sched(struct scheduler *new_ops, unsigned int cpu,
> void *pdata, void *vdata)
> {
> - struct schedule_data *sd = &per_cpu(schedule_data, cpu);
> + struct sched_resource *sd = get_sched_res(cpu);
I can understand why you keep "sd" as a name here and in similar
cases. But ...
> @@ -3881,6 +3881,7 @@ csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu,
> {
> struct csched2_private *prv = csched2_priv(new_ops);
> struct csched2_unit *svc = vdata;
> + struct sched_resource *sd = get_sched_res(cpu);
... here (and in at least one more place) you introduce a new
variable. Wouldn't this better be named e.g. "sr"? Furthermore
you use it just once ...
> @@ -3906,7 +3907,7 @@ csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu,
> * this scheduler, and so it's safe to have taken it /before/ our
> * private global lock.
> */
> - ASSERT(per_cpu(schedule_data, cpu).schedule_lock != &prv->rqd[rqi].lock);
> + ASSERT(sd->schedule_lock != &prv->rqd[rqi].lock);
... here; it doesn't seem worthwhile here, but I guess
subsequent changes make more use of it?
> @@ -393,7 +395,7 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
> /* Idle VCPUs are scheduled immediately, so don't put them in runqueue. */
> if ( is_idle_domain(d) )
> {
> - per_cpu(schedule_data, v->processor).curr = unit;
> + get_sched_res(v->processor)->curr = unit;
As long as it's a macro (see below), why not use curr_on_cpu() here?
> @@ -1916,7 +1917,7 @@ void __init scheduler_init(void)
> idle_domain->max_vcpus = nr_cpu_ids;
> if ( vcpu_create(idle_domain, 0, 0) == NULL )
> BUG();
> - this_cpu(schedule_data).curr = idle_vcpu[0]->sched_unit;
> + get_sched_res(0)->curr = idle_vcpu[0]->sched_unit;
Hmm, yet another plain 0. But yes, there are quite a few of them
here already, so one more doesn't really matter.
> --- a/xen/include/xen/sched-if.h
> +++ b/xen/include/xen/sched-if.h
> @@ -33,22 +33,19 @@ extern int sched_ratelimit_us;
> * For cache betterness, keep the actual lock in the same cache area
> * as the rest of the struct. Just have the scheduler point to the
> * one it wants (This may be the one right in front of it).*/
> -struct schedule_data {
> +struct sched_resource {
> spinlock_t *schedule_lock,
> _lock;
> struct sched_unit *curr;
> void *sched_priv;
> struct timer s_timer; /* scheduling timer */
> - atomic_t urgent_count; /* how many urgent vcpus */
> -};
> -
> -#define curr_on_cpu(c) (per_cpu(schedule_data, c).curr)
>
> -struct sched_resource {
> - unsigned int master_cpu; /* Cpu with lowest id in scheduling resource. */
> + /* Cpu with lowest id in scheduling resource. */
> + unsigned int master_cpu;
> };
>
> -DECLARE_PER_CPU(struct schedule_data, schedule_data);
> +#define curr_on_cpu(c) (get_sched_res(c)->curr)
By moving this a few lines down if could become an inline function
as it seems, if (see above) its use as an lvalue is not intended.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 09/47] xen/sched: move some per-vcpu items to struct sched_unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 09/47] xen/sched: move some per-vcpu items to struct sched_unit Juergen Gross
@ 2019-09-19 15:38 ` Jan Beulich
2019-09-24 11:44 ` Jürgen Groß
2019-09-24 17:23 ` Dario Faggioli
1 sibling, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-19 15:38 UTC (permalink / raw)
To: Juergen Gross
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, Meng Xu, xen-devel, Dario Faggioli
On 14.09.2019 10:52, Juergen Gross wrote:
> Affinities are scheduler specific attributes, they should be per
> scheduling unit. So move all affinity related fields in struct vcpu
> to struct sched_unit. While at it switch affinity related functions in
> sched-if.h to use a pointer to sched_unit instead to vcpu as parameter.
>
> The affinity_broken flag must be kept per vcpu as it is related to
> guest actions on specific vcpus. When support of multiple vcpus per
> sched_unit is being added, a unit is regarded as being subject to
> "broken affinity" when any of its vcpus has the affinity_broken flag
> set.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
> ---
> V2:
> - move affinity_broken back to struct vcpu (Jan Beulich)
> - print affinities only once per unit (Jan Beulich)
> ---
> xen/common/domain.c | 15 ++------
> xen/common/domctl.c | 13 ++++---
> xen/common/keyhandler.c | 58 ++++++++++++++++--------------
Acked-by: Jan Beulich <jbeulich@suse.com>
with one minor remark:
> --- a/xen/common/keyhandler.c
> +++ b/xen/common/keyhandler.c
> @@ -251,6 +251,7 @@ static void reboot_machine(unsigned char key, struct cpu_user_regs *regs)
> static void dump_domains(unsigned char key)
> {
> struct domain *d;
> + struct sched_unit *unit;
> struct vcpu *v;
> s_time_t now = NOW();
I can see how it would look a little odd here because of the
neighboring variables, but generally speaking the new one should
be pointer to const (and the old ones should have been, too,
afaict).
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 10/47] xen/sched: add scheduler helpers hiding vcpu
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 10/47] xen/sched: add scheduler helpers hiding vcpu Juergen Gross
@ 2019-09-19 15:45 ` Jan Beulich
2019-09-24 11:46 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-19 15:45 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 14.09.2019 10:52, Juergen Gross wrote:
> Add the following helpers using a sched_unit as input instead of a
> vcpu:
>
> - is_idle_unit() similar to is_idle_vcpu()
> - is_unit_online() similar to is_vcpu_online() (returns true when any
> of its vcpus is online)
> - unit_runnable() like vcpu_runnable() (returns true if any of its
> vcpus is runnable)
> - sched_set_res() to set the current scheduling resource of a unit
> - sched_unit_cpu() to get the current processor of a unit (returns
> the master_cpu of the scheduling resource of a unit)
And hence perhaps better sched_unit_master() or sched_unit_master_cpu()?
> - sched_{set|clear}_pause_flags[_atomic]() to modify pause_flags of the
> associated vcpu(s) (modifies the pause_flags of all vcpus of the
> unit)
I continue to think that it would have been better to have all of
these have their loops right from the beginning. But it'll be the
scheduler maintainers anyway to ack (or not) the patch in its
current shape.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit Juergen Gross
@ 2019-09-19 15:53 ` Jan Beulich
2019-09-24 11:47 ` Jürgen Groß
2019-09-25 15:27 ` Dario Faggioli
1 sibling, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-19 15:53 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, Meng Xu, xen-devel
On 14.09.2019 10:52, Juergen Gross wrote:
> @@ -1673,8 +1676,10 @@ static void schedule(void)
> * switch, else lost_records resume will not work properly.
> */
>
> - ASSERT(!next->is_running);
> + ASSERT(!next->sched_unit->is_running);
> next->is_running = 1;
> + next->sched_unit->is_running = 1;
Nit: The new field is of type bool, and hence you should write true
and false into it. This may look odd next to the 1 above, but by
the end of the series the two won't sit next to each other anymore.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 23/47] xen/sched: switch sched_move_irqs() to take sched_unit as parameter
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 23/47] xen/sched: switch sched_move_irqs() to take sched_unit as parameter Juergen Gross
@ 2019-09-20 14:34 ` Jan Beulich
2019-09-24 11:55 ` Jürgen Groß
2019-09-24 20:43 ` Dario Faggioli
1 sibling, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-20 14:34 UTC (permalink / raw)
To: Juergen Gross; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 14.09.2019 10:52, Juergen Gross wrote:
> --- a/xen/common/schedule.c
> +++ b/xen/common/schedule.c
> @@ -474,12 +474,20 @@ int sched_init_vcpu(struct vcpu *v)
> return 0;
> }
>
> -static void sched_move_irqs(struct vcpu *v)
> +static void vcpu_move_irqs(struct vcpu *v)
> {
> arch_move_irqs(v);
> evtchn_move_pirqs(v);
> }
>
> +static void sched_move_irqs(struct sched_unit *unit)
I think the parameter could be constified.
> @@ -1736,7 +1744,7 @@ static void schedule(void)
> stop_timer(&prev->vcpu_list->periodic_timer);
>
> if ( next_slice.migrated )
> - sched_move_irqs(next->vcpu_list);
> + vcpu_move_irqs(next->vcpu_list);
Why is this not also sched_move_irqs(), at which point there wouldn't
be a need for a separate vcpu_move_irqs() afaict?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 24/47] xen: switch from for_each_vcpu() to for_each_sched_unit()
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 24/47] xen: switch from for_each_vcpu() to for_each_sched_unit() Juergen Gross
@ 2019-09-20 15:05 ` Jan Beulich
2019-09-24 12:13 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-20 15:05 UTC (permalink / raw)
To: Juergen Gross, Joshua Whitehead, Robert VanVossen
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli
On 14.09.2019 10:52, Juergen Gross wrote:
> @@ -508,25 +515,27 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
> if ( IS_ERR(domdata) )
> return PTR_ERR(domdata);
>
> - vcpu_priv = xzalloc_array(void *, d->max_vcpus);
> - if ( vcpu_priv == NULL )
> + /* TODO: fix array size with multiple vcpus per unit. */
> + unit_priv = xzalloc_array(void *, d->max_vcpus);
> + if ( unit_priv == NULL )
> {
> sched_free_domdata(c->sched, domdata);
> return -ENOMEM;
> }
>
> - for_each_vcpu ( d, v )
> + unit_idx = 0;
> + for_each_sched_unit ( d, unit )
> {
> - vcpu_priv[v->vcpu_id] = sched_alloc_vdata(c->sched, v->sched_unit,
> - domdata);
> - if ( vcpu_priv[v->vcpu_id] == NULL )
> + unit_priv[unit_idx] = sched_alloc_vdata(c->sched, unit, domdata);
> + if ( unit_priv[unit_idx] == NULL )
> {
> - for_each_vcpu ( d, v )
> - xfree(vcpu_priv[v->vcpu_id]);
> - xfree(vcpu_priv);
> + for ( unit_idx = 0; unit_priv[unit_idx]; unit_idx++ )
> + sched_free_vdata(c->sched, unit_priv[unit_idx]);
This is an unexpected change from xfree() to sched_free_vdata(). If
it really is correct, it should be mentioned in the description. I
can see why this might be better from an abstract pov, but it's
questionable whether arinc653's update_schedule_vcpus() really wants
calling at this point (perhaps it does, as a653sched_alloc_vdata()
also calls it).
Josh, Robert: Besides this immediate aspect I also wonder whether
said call is correct to make outside of a sched_priv->lock'ed
region, when both other instances occur inside of one (and in one
case immediately before an unlock, i.e. if the lock wasn't needed
the two steps could well be re-ordered).
Finally, at this point, shouldn't the functions and hooks (already)
be named {alloc,free}_udata()?
> @@ -896,18 +929,22 @@ void restore_vcpu_affinity(struct domain *d)
> cpupool_domain_cpumask(d));
> if ( cpumask_empty(cpumask_scratch_cpu(cpu)) )
> {
> - if ( v->affinity_broken )
> + if ( sched_check_affinity_broken(unit) )
> {
> - sched_set_affinity(v, unit->cpu_hard_affinity_saved, NULL);
> - v->affinity_broken = 0;
> + /* Affinity settings of one vcpu are for the complete unit. */
> + sched_set_affinity(unit->vcpu_list,
> + unit->cpu_hard_affinity_saved, NULL);
Yet despite the comment the function gets passed a struct vcpu *,
and this doesn't look to change by the end of the series. Is there
a reason for this?
> @@ -950,17 +986,19 @@ int cpu_disable_scheduler(unsigned int cpu)
>
> for_each_domain_in_cpupool ( d, c )
> {
> - for_each_vcpu ( d, v )
> + struct sched_unit *unit;
> +
> + for_each_sched_unit ( d, unit )
> {
> unsigned long flags;
> - struct sched_unit *unit = v->sched_unit;
> spinlock_t *lock = unit_schedule_lock_irqsave(unit, &flags);
>
> cpumask_and(&online_affinity, unit->cpu_hard_affinity, c->cpu_valid);
> if ( cpumask_empty(&online_affinity) &&
> cpumask_test_cpu(cpu, unit->cpu_hard_affinity) )
> {
> - if ( v->affinity_broken )
> + /* TODO: multiple vcpus per unit. */
> + if ( unit->vcpu_list->affinity_broken )
Why not sched_check_affinity_broken(unit)? Quite possibly this would
make the TODO item unnecessary?
> @@ -968,14 +1006,15 @@ int cpu_disable_scheduler(unsigned int cpu)
> break;
> }
>
> - printk(XENLOG_DEBUG "Breaking affinity for %pv\n", v);
> + printk(XENLOG_DEBUG "Breaking affinity for %pv\n",
> + unit->vcpu_list);
>
> - sched_set_affinity(v, &cpumask_all, NULL);
> + sched_set_affinity(unit->vcpu_list, &cpumask_all, NULL);
> }
>
> - if ( v->processor != cpu )
> + if ( sched_unit_cpu(unit) != sched_get_resource_cpu(cpu) )
Didn't you agree that this can be had cheaper? Quite likely my v2
review remark was on a different instance, but the pattern ought
to be relatively simple to find in the entire series (and by the
end of the series there's one other instance in schedule.c ...
> @@ -988,17 +1027,18 @@ int cpu_disable_scheduler(unsigned int cpu)
> * * the scheduler will always find a suitable solution, or
> * things would have failed before getting in here.
> */
> - vcpu_migrate_start(v);
> + /* TODO: multiple vcpus per unit. */
> + vcpu_migrate_start(unit->vcpu_list);
> unit_schedule_unlock_irqrestore(lock, flags, unit);
>
> - vcpu_migrate_finish(v);
> + vcpu_migrate_finish(unit->vcpu_list);
>
> /*
> * The only caveat, in this case, is that if a vcpu active in
> * the hypervisor isn't migratable. In this case, the caller
> * should try again after releasing and reaquiring all locks.
> */
> - if ( v->processor == cpu )
> + if ( sched_unit_cpu(unit) == sched_get_resource_cpu(cpu) )
... here; I didn't check other files).
> @@ -1009,8 +1049,8 @@ int cpu_disable_scheduler(unsigned int cpu)
> static int cpu_disable_scheduler_check(unsigned int cpu)
> {
> struct domain *d;
> - struct vcpu *v;
> struct cpupool *c;
> + struct vcpu *v;
Unnecessary change?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 25/47] xen/sched: add runstate counters to struct sched_unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 25/47] xen/sched: add runstate counters to struct sched_unit Juergen Gross
@ 2019-09-20 15:27 ` Jan Beulich
2019-09-24 13:50 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-20 15:27 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 14.09.2019 10:52, Juergen Gross wrote:
> @@ -368,7 +372,7 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
> unit->vcpu_list = v;
> unit->unit_id = v->vcpu_id;
> unit->domain = d;
> - v->sched_unit = unit;
> + unit->runstate_cnt[v->runstate.state]++;
>
> for ( prev_unit = &d->sched_unit_list; *prev_unit;
> prev_unit = &(*prev_unit)->next_in_list )
> @@ -384,6 +388,8 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
> !zalloc_cpumask_var(&unit->cpu_soft_affinity) )
> goto fail;
>
> + v->sched_unit = unit;
> +
> return unit;
>
> fail:
Is this movement of the assignment something which really belongs
here, rather than in some earlier patch (perhaps the one actually
introducing it)?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 28/47] xen/sched: add code to sync scheduling of all vcpus of a sched unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 28/47] xen/sched: add code to sync scheduling of all vcpus of a sched unit Juergen Gross
@ 2019-09-20 16:08 ` Jan Beulich
2019-09-24 14:14 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-20 16:08 UTC (permalink / raw)
To: Juergen Gross
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli, Volodymyr Babchuk,
Roger Pau Monné
On 14.09.2019 10:52, Juergen Gross wrote:
> --- a/xen/common/schedule.c
> +++ b/xen/common/schedule.c
> @@ -55,6 +55,9 @@ boolean_param("sched_smt_power_savings", sched_smt_power_savings);
> int sched_ratelimit_us = SCHED_DEFAULT_RATELIMIT_US;
> integer_param("sched_ratelimit_us", sched_ratelimit_us);
>
> +/* Number of vcpus per struct sched_unit. */
> +static unsigned int __read_mostly sched_granularity = 1;
Didn't you indicate earlier that this would be a per-pool property?
Or was that just a longer term plan?
> +/*
> + * Rendezvous before taking a scheduling decision.
> + * Called with schedule lock held, so all accesses to the rendezvous counter
> + * can be normal ones (no atomic accesses needed).
> + * The counter is initialized to the number of cpus to rendezvous initially.
> + * Each cpu entering will decrement the counter. In case the counter becomes
> + * zero do_schedule() is called and the rendezvous counter for leaving
> + * context_switch() is set. All other members will wait until the counter is
> + * becoming zero, dropping the schedule lock in between.
> + */
This recurring lock/unlock is liable to cause a massive cache line
ping-pong, especially for socket or node scheduling. Instead of
just a cpu_relax() between the main unlock and re-lock, could there
perhaps be lock-less checks to determine whether there's any point
at all re-acquiring the lock?
> +static void schedule(void)
> +{
> + struct vcpu *vnext, *vprev = current;
> + struct sched_unit *prev = vprev->sched_unit, *next = NULL;
> + s_time_t now;
> + struct sched_resource *sd;
> + spinlock_t *lock;
> + int cpu = smp_processor_id();
> +
> + ASSERT_NOT_IN_ATOMIC();
> +
> + SCHED_STAT_CRANK(sched_run);
> +
> + sd = get_sched_res(cpu);
> +
> + lock = pcpu_schedule_lock_irq(cpu);
> +
> + if ( prev->rendezvous_in_cnt )
> + {
> + /*
> + * We have a race: sched_slave() should be called, so raise a softirq
> + * in order to re-enter schedule() later and call sched_slave() now.
> + */
> + pcpu_schedule_unlock_irq(lock, cpu);
> +
> + raise_softirq(SCHEDULE_SOFTIRQ);
> + return sched_slave();
> + }
> +
> + now = NOW();
> +
> + stop_timer(&sd->s_timer);
Is the order of these two relevant? A while ago there were a couple
of changes moving such NOW() invocations past anything that may take
non-negligible time, to make accounting as accurate as possible.
> --- a/xen/include/xen/softirq.h
> +++ b/xen/include/xen/softirq.h
> @@ -4,6 +4,7 @@
> /* Low-latency softirqs come first in the following list. */
> enum {
> TIMER_SOFTIRQ = 0,
> + SCHED_SLAVE_SOFTIRQ,
> SCHEDULE_SOFTIRQ,
> NEW_TLBFLUSH_CLOCK_PERIOD_SOFTIRQ,
> RCU_SOFTIRQ,
Seeing the comment, is the insertion you do as well as the pre-
existing placement of SCHEDULE_SOFTIRQ still appropriate with
the rendezvous-ing you introduce?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (46 preceding siblings ...)
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 47/47] xen/sched: add scheduling granularity enum Juergen Gross
@ 2019-09-20 16:14 ` Jan Beulich
2019-09-24 10:36 ` Dario Faggioli
2019-09-24 11:15 ` Sergey Dyasli
48 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-20 16:14 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Dario Faggioli, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Volodymyr Babchuk, Roger Pau Monné
On 14.09.2019 10:52, Juergen Gross wrote:
> This is achieved by switching the scheduler to no longer see vcpus as
> the primary object to schedule, but "schedule units". Each schedule
> unit consists of as many vcpus as each core has threads on the current
> system. The vcpu->unit relation is fixed.
There's another aspect here that, while perhaps obvious, I didn't
realize so far: Iirc right now schedulers try to place vCPU-s on
different cores, as long as there aren't more runnable vCPU-s than
there are cores. This is to improve overall throughput, since
vCPU-s on sibling hyperthreads would compete for execution
resources. With a fixed relation this is going to be impossible.
Otoh I can of course see how, once we have proper virtual
topology, this allows better scheduling decisions inside the
guest, in particular if - under the right circumstances - it is
actually wanted to run two entities on sibling threads.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 29/47] xen/sched: introduce unit_runnable_state()
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 29/47] xen/sched: introduce unit_runnable_state() Juergen Gross
@ 2019-09-23 15:24 ` Jan Beulich
2019-09-24 14:25 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-23 15:24 UTC (permalink / raw)
To: Juergen Gross
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Tim Deegan, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Dario Faggioli
On 14.09.2019 10:52, Juergen Gross wrote:
> Today the vcpu runstate of a new scheduled vcpu is always set to
> "running" even if at that time vcpu_runnable() is already returning
> false due to a race (e.g. with pausing the vcpu).
I can see this part, ...
> With core scheduling this can no longer work as not all vcpus of a
> schedule unit have to be "running" when being scheduled. So the vcpu's
> new runstate has to be selected at the same time as the runnability of
> the related schedule unit is probed.
... but I continue having trouble here. If it has been okay to set
a vCPU no longer runnable to "running" nevertheless, why would the
same not be true for schedule units? Part of the problem may be
that ...
> --- a/xen/include/xen/sched-if.h
> +++ b/xen/include/xen/sched-if.h
> @@ -76,6 +76,29 @@ static inline bool unit_runnable(const struct sched_unit *unit)
> return vcpu_runnable(unit->vcpu_list);
... this clearly still isn't doing the (I suppose) intended loop,
and hence ...
> }
>
> +static inline bool unit_runnable_state(const struct sched_unit *unit)
> +{
> + struct vcpu *v;
> + bool runnable, ret = false;
> +
> + if ( is_idle_unit(unit) )
> + return true;
> +
> + for_each_sched_unit_vcpu ( unit, v )
> + {
> + runnable = vcpu_runnable(v);
> +
> + v->new_state = runnable ? RUNSTATE_running
> + : (v->pause_flags & VPF_blocked)
> + ? RUNSTATE_blocked : RUNSTATE_offline;
> +
> + if ( runnable )
> + ret = true;
> + }
> +
> + return ret;
> +}
... it's not obvious what the eventual difference between the two is
going to be.
Furthermore I think a function of the given name, returning bool, and
taking a pointer to const deserves a comment as to the (possibly
slightly unexpected) state change it does. This comment might then be
worthwhile to extend to also outline the usage difference between it
and its sibling above.
> --- a/xen/include/xen/sched.h
> +++ b/xen/include/xen/sched.h
> @@ -174,6 +174,7 @@ struct vcpu
> XEN_GUEST_HANDLE(vcpu_runstate_info_compat_t) compat;
> } runstate_guest; /* guest address */
> #endif
> + unsigned int new_state;
Similarly I think it would be nice for this field to gain a brief
comment as to its purpose compared to runstate.state.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing Juergen Gross
@ 2019-09-23 15:41 ` Jan Beulich
2019-09-24 14:41 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-23 15:41 UTC (permalink / raw)
To: Juergen Gross
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli
On 14.09.2019 10:52, Juergen Gross wrote:
> @@ -266,15 +267,16 @@ static inline void vcpu_runstate_change(
> static inline void sched_unit_runstate_change(struct sched_unit *unit,
> bool running, s_time_t new_entry_time)
> {
> - struct vcpu *v = unit->vcpu_list;
> + struct vcpu *v;
>
> - if ( running )
> - vcpu_runstate_change(v, v->new_state, new_entry_time);
> - else
> - vcpu_runstate_change(v,
> - ((v->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
> - (vcpu_runnable(v) ? RUNSTATE_runnable : RUNSTATE_offline)),
> - new_entry_time);
> + for_each_sched_unit_vcpu ( unit, v )
> + if ( running )
> + vcpu_runstate_change(v, v->new_state, new_entry_time);
> + else
> + vcpu_runstate_change(v,
> + ((v->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
> + (vcpu_runnable(v) ? RUNSTATE_runnable : RUNSTATE_offline)),
> + new_entry_time);
> }
As mentioned on v2 already, I'm having some difficulty seeing why a
function like this one (and some of the sched-if.h changes here)
couldn't be introduced with this loop you add now right away.
Seeing this change I'm also puzzled why ->new_state is used only in
case "running" is true. Is there anything speaking against setting
that field uniformly, and simply consuming it here in all cases?
> @@ -1031,10 +1033,9 @@ int cpu_disable_scheduler(unsigned int cpu)
> if ( cpumask_empty(&online_affinity) &&
> cpumask_test_cpu(cpu, unit->cpu_hard_affinity) )
> {
> - /* TODO: multiple vcpus per unit. */
> - if ( unit->vcpu_list->affinity_broken )
> + if ( sched_check_affinity_broken(unit) )
> {
> - /* The vcpu is temporarily pinned, can't move it. */
> + /* The unit is temporarily pinned, can't move it. */
> unit_schedule_unlock_irqrestore(lock, flags, unit);
Along these lines, wouldn't this change (and further related ones)
belong into the patch introducing sched_check_affinity_broken()?
> @@ -1851,7 +1852,7 @@ void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
> while ( atomic_read(&next->rendezvous_out_cnt) )
> cpu_relax();
> }
> - else if ( vprev != vnext )
> + else if ( vprev != vnext && sched_granularity == 1 )
> context_saved(vprev);
> }
Would you mind helping me with understanding why this call is
needed with a granularity of 1 only?
> --- a/xen/include/xen/sched-if.h
> +++ b/xen/include/xen/sched-if.h
> @@ -68,12 +68,32 @@ static inline bool is_idle_unit(const struct sched_unit *unit)
>
> static inline bool is_unit_online(const struct sched_unit *unit)
> {
> - return is_vcpu_online(unit->vcpu_list);
> + struct vcpu *v;
const?
> + for_each_sched_unit_vcpu ( unit, v )
> + if ( is_vcpu_online(v) )
> + return true;
> +
> + return false;
> +}
> +
> +static inline unsigned int unit_running(const struct sched_unit *unit)
> +{
> + return unit->runstate_cnt[RUNSTATE_running];
> }
Is there really going to be a user needing the return value be a
count, not just a boolean?
> static inline bool unit_runnable(const struct sched_unit *unit)
> {
> - return vcpu_runnable(unit->vcpu_list);
> + struct vcpu *v;
const?
> + if ( is_idle_unit(unit) )
> + return true;
> +
> + for_each_sched_unit_vcpu ( unit, v )
> + if ( vcpu_runnable(v) )
> + return true;
Isn't the loop going to yield true anyway for idle units? If so, is
there a particular reason for the special casing of idle units up
front here?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 31/47] xen/sched: modify cpupool_domain_cpumask() to be an unit mask
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 31/47] xen/sched: modify cpupool_domain_cpumask() to be an unit mask Juergen Gross
@ 2019-09-23 15:44 ` Jan Beulich
2019-09-24 14:45 ` Jürgen Groß
2019-09-23 15:50 ` Jan Beulich
1 sibling, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-23 15:44 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 14.09.2019 10:52, Juergen Gross wrote:
> cpupool_domain_cpumask() is used by scheduling to select cpus or to
> iterate over cpus. In order to support scheduling units spanning
> multiple cpus let cpupool_domain_cpumask() return a cpumask with only
> one bit set per scheduling resource.
I guess this renders the name misleading: How about a rename to
cpupool_domain_master_cpumask(), along the lines of "master_cpu"?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 31/47] xen/sched: modify cpupool_domain_cpumask() to be an unit mask
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 31/47] xen/sched: modify cpupool_domain_cpumask() to be an unit mask Juergen Gross
2019-09-23 15:44 ` Jan Beulich
@ 2019-09-23 15:50 ` Jan Beulich
2019-09-24 14:46 ` Jürgen Groß
1 sibling, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-23 15:50 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 14.09.2019 10:52, Juergen Gross wrote:
> --- a/xen/common/cpupool.c
> +++ b/xen/common/cpupool.c
> @@ -36,26 +36,35 @@ static DEFINE_SPINLOCK(cpupool_lock);
>
> DEFINE_PER_CPU(struct cpupool *, cpupool);
>
> +static void free_cpupool_struct(struct cpupool *c)
> +{
> + if ( c )
> + {
> + free_cpumask_var(c->res_valid);
> + free_cpumask_var(c->cpu_valid);
> + }
> + xfree(c);
> +}
> +
> static struct cpupool *alloc_cpupool_struct(void)
> {
> struct cpupool *c = xzalloc(struct cpupool);
>
> - if ( !c || !zalloc_cpumask_var(&c->cpu_valid) )
> + if ( !c )
> + return NULL;
> +
> + zalloc_cpumask_var(&c->cpu_valid);
> + zalloc_cpumask_var(&c->res_valid);
> +
> + if ( !c->cpu_valid || !c->res_valid )
I guess compilers (or other static analysis tools) may warn about
this for NR_CPUS <= 2 * BITS_PER_LONG builds. The intention really
is for you to check zalloc_cpumask_var()'s return value; perhaps
it should get [have been] marked "__must_check".
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 32/47] xen/sched: support allocating multiple vcpus into one sched unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 32/47] xen/sched: support allocating multiple vcpus into one sched unit Juergen Gross
@ 2019-09-24 9:46 ` Jan Beulich
2019-09-24 10:06 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 9:46 UTC (permalink / raw)
To: Juergen Gross; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 14.09.2019 10:52, Juergen Gross wrote:
> @@ -366,18 +380,38 @@ static void sched_free_unit(struct sched_unit *unit)
> xfree(unit);
> }
>
> +static void sched_unit_add_vcpu(struct sched_unit *unit, struct vcpu *v)
> +{
> + v->sched_unit = unit;
> + if ( !unit->vcpu_list || unit->vcpu_list->vcpu_id > v->vcpu_id )
Is the right side needed? Aren't vCPU-s created in increasing order
of their IDs, and aren't we relying on this elsewhere too?
> + {
> + unit->vcpu_list = v;
> + unit->unit_id = v->vcpu_id;
This makes for a pretty strange set of IDs (non-successive), and
explains why patch 24 uses a local "unit_idx" instead of switching
from v->vcpu_id as array index to unit->unit_id. Is there a reason
you don't divide by the granularity here, eliminating the division
done e.g. ...
> + }
> + unit->runstate_cnt[v->runstate.state]++;
> +}
> +
> static struct sched_unit *sched_alloc_unit(struct vcpu *v)
> {
> struct sched_unit *unit, **prev_unit;
> struct domain *d = v->domain;
>
> + for_each_sched_unit ( d, unit )
> + if ( unit->vcpu_list->vcpu_id / sched_granularity ==
... here. (I also don't see why you don't use unit->unit_id here.)
> @@ -622,9 +659,16 @@ void sched_destroy_vcpu(struct vcpu *v)
> kill_timer(&v->poll_timer);
> if ( test_and_clear_bool(v->is_urgent) )
> atomic_dec(&per_cpu(sched_urgent_count, v->processor));
> - sched_remove_unit(vcpu_scheduler(v), unit);
> - sched_free_vdata(vcpu_scheduler(v), unit->priv);
> - sched_free_unit(unit);
> + /*
> + * Vcpus are being destroyed top-down. So being the first vcpu of an unit
> + * is the same as being the only one.
> + */
> + if ( unit->vcpu_list == v )
Interestingly here you rely on there being a certain order.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 33/47] xen/sched: add a percpu resource index
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 33/47] xen/sched: add a percpu resource index Juergen Gross
@ 2019-09-24 10:05 ` Jan Beulich
2019-09-24 15:20 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 10:05 UTC (permalink / raw)
To: Juergen Gross; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 14.09.2019 10:52, Juergen Gross wrote:
> --- a/xen/common/schedule.c
> +++ b/xen/common/schedule.c
> @@ -71,6 +71,7 @@ static void poll_timer_fn(void *data);
> /* This is global for now so that private implementations can reach it */
> DEFINE_PER_CPU(struct scheduler *, scheduler);
> DEFINE_PER_CPU_READ_MOSTLY(struct sched_resource *, sched_res);
> +static DEFINE_PER_CPU_READ_MOSTLY(unsigned int, sched_res_idx);
It's of course not very helpful that this variable (right here) doesn't
ever get written to, and hence one can't judge where / how this is to
be done (without going look elsewhere). But I guess that calculation
can't be moved into this patch (accepting that it would always yield
zero for now)?
> @@ -135,6 +136,12 @@ static struct scheduler sched_idle_ops = {
> .switch_sched = sched_idle_switch_sched,
> };
>
> +static inline struct vcpu *sched_unit2vcpu_cpu(struct sched_unit *unit,
const (on the parameter)?
> + unsigned int cpu)
> +{
> + return unit->domain->vcpu[unit->unit_id + per_cpu(sched_res_idx, cpu)];
> +}
> +
> static inline struct scheduler *dom_scheduler(const struct domain *d)
> {
> if ( likely(d->cpupool != NULL) )
> @@ -2008,7 +2015,7 @@ static void sched_slave(void)
>
> pcpu_schedule_unlock_irq(lock, cpu);
>
> - sched_context_switch(vprev, next->vcpu_list, now);
> + sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu), now);
> }
By the end of the series this will be
sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu),
is_idle_unit(next) && !is_idle_unit(prev), now);
clarifying (I think) that "next" can indeed be an idle unit. I'm having
difficulty seeing how can produce the correct result in all three cases
- all vCPU-s in the unit belong to a real domain
- all vCPU-s in the unit belong to the idle domain
- there's a mix of "real" and (filler) "idle" vCPU-s
My main question is what "next" is in the last of the 3 cases above.
Considering that scheduling happens in terms of units, I'd expect it to
be a real domain's unit, yet then I don't see how you'd get at the
correct (idle) vCPU when calling sched_unit2vcpu_cpu(next, cpu).
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 32/47] xen/sched: support allocating multiple vcpus into one sched unit
2019-09-24 9:46 ` Jan Beulich
@ 2019-09-24 10:06 ` Jürgen Groß
2019-09-24 10:13 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 10:06 UTC (permalink / raw)
To: Jan Beulich; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 24.09.19 11:46, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> @@ -366,18 +380,38 @@ static void sched_free_unit(struct sched_unit *unit)
>> xfree(unit);
>> }
>>
>> +static void sched_unit_add_vcpu(struct sched_unit *unit, struct vcpu *v)
>> +{
>> + v->sched_unit = unit;
>> + if ( !unit->vcpu_list || unit->vcpu_list->vcpu_id > v->vcpu_id )
>
> Is the right side needed? Aren't vCPU-s created in increasing order
> of their IDs, and aren't we relying on this elsewhere too?
Idle vcpus are rather special and they require the second test.
>
>> + {
>> + unit->vcpu_list = v;
>> + unit->unit_id = v->vcpu_id;
>
> This makes for a pretty strange set of IDs (non-successive), and
> explains why patch 24 uses a local "unit_idx" instead of switching
> from v->vcpu_id as array index to unit->unit_id. Is there a reason
> you don't divide by the granularity here, eliminating the division
> done e.g. ...
Cpus not in a cpupool are in single-vcpu units, so in order for not
having completely weird unit-ids after having move cpus a lot in and
out of cpupools keeping the current scheme is the only one I could
think of.
>
>> + }
>> + unit->runstate_cnt[v->runstate.state]++;
>> +}
>> +
>> static struct sched_unit *sched_alloc_unit(struct vcpu *v)
>> {
>> struct sched_unit *unit, **prev_unit;
>> struct domain *d = v->domain;
>>
>> + for_each_sched_unit ( d, unit )
>> + if ( unit->vcpu_list->vcpu_id / sched_granularity ==
>
> ... here. (I also don't see why you don't use unit->unit_id here.)
>
>> @@ -622,9 +659,16 @@ void sched_destroy_vcpu(struct vcpu *v)
>> kill_timer(&v->poll_timer);
>> if ( test_and_clear_bool(v->is_urgent) )
>> atomic_dec(&per_cpu(sched_urgent_count, v->processor));
>> - sched_remove_unit(vcpu_scheduler(v), unit);
>> - sched_free_vdata(vcpu_scheduler(v), unit->priv);
>> - sched_free_unit(unit);
>> + /*
>> + * Vcpus are being destroyed top-down. So being the first vcpu of an unit
>> + * is the same as being the only one.
>> + */
>> + if ( unit->vcpu_list == v )
>
> Interestingly here you rely on there being a certain order.
Yes. That is working because idle vcpus are never destroyed.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 32/47] xen/sched: support allocating multiple vcpus into one sched unit
2019-09-24 10:06 ` Jürgen Groß
@ 2019-09-24 10:13 ` Jan Beulich
2019-09-24 15:13 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 10:13 UTC (permalink / raw)
To: Jürgen Groß; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 24.09.2019 12:06, Jürgen Groß wrote:
> On 24.09.19 11:46, Jan Beulich wrote:
>> On 14.09.2019 10:52, Juergen Gross wrote:
>>> @@ -366,18 +380,38 @@ static void sched_free_unit(struct sched_unit *unit)
>>> xfree(unit);
>>> }
>>>
>>> +static void sched_unit_add_vcpu(struct sched_unit *unit, struct vcpu *v)
>>> +{
>>> + v->sched_unit = unit;
>>> + if ( !unit->vcpu_list || unit->vcpu_list->vcpu_id > v->vcpu_id )
>>
>> Is the right side needed? Aren't vCPU-s created in increasing order
>> of their IDs, and aren't we relying on this elsewhere too?
>
> Idle vcpus are rather special and they require the second test.
How about a code comment to this effect?
>>> + {
>>> + unit->vcpu_list = v;
>>> + unit->unit_id = v->vcpu_id;
>>
>> This makes for a pretty strange set of IDs (non-successive), and
>> explains why patch 24 uses a local "unit_idx" instead of switching
>> from v->vcpu_id as array index to unit->unit_id. Is there a reason
>> you don't divide by the granularity here, eliminating the division
>> done e.g. ...
>
> Cpus not in a cpupool are in single-vcpu units, so in order for not
> having completely weird unit-ids after having move cpus a lot in and
> out of cpupools keeping the current scheme is the only one I could
> think of.
And how about extending the description to include this?
>>> + }
>>> + unit->runstate_cnt[v->runstate.state]++;
>>> +}
>>> +
>>> static struct sched_unit *sched_alloc_unit(struct vcpu *v)
>>> {
>>> struct sched_unit *unit, **prev_unit;
>>> struct domain *d = v->domain;
>>>
>>> + for_each_sched_unit ( d, unit )
>>> + if ( unit->vcpu_list->vcpu_id / sched_granularity ==
>>
>> ... here. (I also don't see why you don't use unit->unit_id here.)
And is there a reason not to use unit->unit_id here then, which
is slightly cheaper to access?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support
2019-09-20 16:14 ` [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Jan Beulich
@ 2019-09-24 10:36 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-24 10:36 UTC (permalink / raw)
To: Jan Beulich, Juergen Gross
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Tim Deegan, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Volodymyr Babchuk, Roger Pau Monné
[-- Attachment #1.1: Type: text/plain, Size: 2503 bytes --]
On Fri, 2019-09-20 at 18:14 +0200, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
> > This is achieved by switching the scheduler to no longer see vcpus
> > as
> > the primary object to schedule, but "schedule units". Each schedule
> > unit consists of as many vcpus as each core has threads on the
> > current
> > system. The vcpu->unit relation is fixed.
>
> There's another aspect here that, while perhaps obvious, I didn't
> realize so far: Iirc right now schedulers try to place vCPU-s on
> different cores, as long as there aren't more runnable vCPU-s than
> there are cores.
>
Indeed they do.
> This is to improve overall throughput, since
> vCPU-s on sibling hyperthreads would compete for execution
> resources. With a fixed relation this is going to be impossible.
>
It is. And that is the reason why my benchmarks show rather bad
performance for a 4 vCUPUs VMs on a 8 CPUs (4 cores, with
hyperthreading) host. In fact, as Juergen showed during his Xen Summit
talk, in such a case core-scheduling achieves much worse performance
than "regular" cpu-scheduling, both when hyperthreading is enabled and
disabled.
It's an intrinsic characteristic of this solution that we have decided
to go for (i.e., introducing the 'virtual core' and 'scheduling
resource' concepts, and act almost entirely at the schedule.c level).
> Otoh I can of course see how, once we have proper virtual
> topology, this allows better scheduling decisions inside the
> guest, in particular if - under the right circumstances - it is
> actually wanted to run two entities on sibling threads.
>
Yes, this is indeed one aspect. There is also the fact that, currently,
as soon as you have 1 more vCPU than there are cores, e.g. coming from
another VM, the guest that had each of its vCPUs running on one core,
experiences a slowdown. While, with core-scheduling enabled from the
beginning, performance stays consistent.
In any case, this all happens with core-scheduling actually enabled.
With these patches applied, but cpu-scheduling selected at boot, fully
idle cores are still preferred, and the vCPUs will still be spread
among them (as soon as there's any available).
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 34/47] xen/sched: add fall back to idle vcpu when scheduling unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 34/47] xen/sched: add fall back to idle vcpu when scheduling unit Juergen Gross
@ 2019-09-24 10:53 ` Jan Beulich
2019-09-25 12:58 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 10:53 UTC (permalink / raw)
To: Juergen Gross
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli, Volodymyr Babchuk,
Roger Pau Monné
On 14.09.2019 10:52, Juergen Gross wrote:
> When scheduling an unit with multiple vcpus there is no guarantee all
> vcpus are available (e.g. above maxvcpus or vcpu offline). Fall back to
> idle vcpu of the current cpu in that case. This requires to store the
> correct schedule_unit pointer in the idle vcpu as long as it used as
> fallback vcpu.
>
> In order to modify the runstates of the correct vcpus when switching
> schedule units merge sched_unit_runstate_change() into
> sched_switch_units() and loop over the affected physical cpus instead
> of the unit's vcpus. This in turn requires an access function to the
> current variable of other cpus.
>
> Today context_saved() is called in case previous and next vcpus differ
> when doing a context switch. With an idle vcpu being capable to be a
> substitute for an offline vcpu this is problematic when switching to
> an idle scheduling unit. An idle previous vcpu leaves us in doubt which
> schedule unit was active previously, so save the previous unit pointer
> in the per-schedule resource area. If it is NULL the unit has not
> changed and we don't have to set the previous unit to be not running.
>
> When running an idle vcpu in a non-idle scheduling unit use a specific
> guest idle loop not performing any tasklets and livepatching in order
> to avoid populating the cpu caches with memory used by other domains
> (as far as possible). Softirqs are considered to be save.
Aiui "tasklets" here means only ones run in (idle) vCPU context, whereas
"softirqs" includes tasklets run in softirq context. I think it would
help if the description made this distinction. With this I then wonder
whether the cache related argumentation above still holds: VT-d's IOMMU
fault handling tasklet runs in softirq context, for example, and
hvm_assert_evtchn_irq(), being handed a struct vcpu *, does too. Of
course this could be considered covered by "(as far as possible)" ...
> @@ -172,6 +191,10 @@ void startup_cpu_idle_loop(void)
>
> static void noreturn continue_idle_domain(struct vcpu *v)
> {
> + /* Idle vcpus might be attached to non-idle units! */
> + if ( !is_idle_domain(v->sched_unit->domain) )
> + reset_stack_and_jump_nolp(guest_idle_loop);
The construct and comment make me wonder - did you audit all uses
of is_idle_{domain,vcpu}() for being in line with this new usage
mode?
> @@ -1767,33 +1774,66 @@ static void sched_switch_units(struct sched_resource *sd,
> struct sched_unit *next, struct sched_unit *prev,
> s_time_t now)
> {
> - sd->curr = next;
> -
> - TRACE_3D(TRC_SCHED_SWITCH_INFPREV, prev->domain->domain_id, prev->unit_id,
> - now - prev->state_entry_time);
> - TRACE_4D(TRC_SCHED_SWITCH_INFNEXT, next->domain->domain_id, next->unit_id,
> - (next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
> - (now - next->state_entry_time) : 0, prev->next_time);
> + int cpu;
unsigned int?
> ASSERT(unit_running(prev));
>
> - TRACE_4D(TRC_SCHED_SWITCH, prev->domain->domain_id, prev->unit_id,
> - next->domain->domain_id, next->unit_id);
> + if ( prev != next )
> + {
> + sd->curr = next;
> + sd->prev = prev;
>
> - sched_unit_runstate_change(prev, false, now);
> + TRACE_3D(TRC_SCHED_SWITCH_INFPREV, prev->domain->domain_id,
> + prev->unit_id, now - prev->state_entry_time);
> + TRACE_4D(TRC_SCHED_SWITCH_INFNEXT, next->domain->domain_id,
> + next->unit_id,
> + (next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
> + (now - next->state_entry_time) : 0, prev->next_time);
> + TRACE_4D(TRC_SCHED_SWITCH, prev->domain->domain_id, prev->unit_id,
> + next->domain->domain_id, next->unit_id);
>
> - ASSERT(!unit_running(next));
> - sched_unit_runstate_change(next, true, now);
> + ASSERT(!unit_running(next));
>
> - /*
> - * NB. Don't add any trace records from here until the actual context
> - * switch, else lost_records resume will not work properly.
> - */
> + /*
> + * NB. Don't add any trace records from here until the actual context
> + * switch, else lost_records resume will not work properly.
> + */
> +
> + ASSERT(!next->is_running);
> + next->is_running = 1;
> + next->state_entry_time = now;
> +
> + if ( is_idle_unit(prev) )
> + {
> + prev->runstate_cnt[RUNSTATE_running] = 0;
> + prev->runstate_cnt[RUNSTATE_runnable] = sched_granularity;
> + }
> + if ( is_idle_unit(next) )
> + {
> + next->runstate_cnt[RUNSTATE_running] = sched_granularity;
> + next->runstate_cnt[RUNSTATE_runnable] = 0;
> + }
Is this correct when some of the vCPU-s a substitute idle ones?
> @@ -1849,29 +1889,39 @@ static struct sched_unit *do_schedule(struct sched_unit *prev, s_time_t now,
> if ( prev->next_time >= 0 ) /* -ve means no limit */
> set_timer(&sd->s_timer, now + prev->next_time);
>
> - if ( likely(prev != next) )
> - sched_switch_units(sd, next, prev, now);
> + sched_switch_units(sd, next, prev, now);
>
> return next;
> }
>
> -static void context_saved(struct vcpu *prev)
> +static void vcpu_context_saved(struct vcpu *vprev, struct vcpu *vnext)
> {
> - struct sched_unit *unit = prev->sched_unit;
> -
> /* Clear running flag /after/ writing context to memory. */
> smp_wmb();
>
> - prev->is_running = 0;
> + if ( vprev != vnext )
> + vprev->is_running = 0;
> +}
With this "vnext" could be const qualified as it seems. And "false"
instead of "0" perhaps, as you touch this anyway?
> @@ -2015,7 +2079,8 @@ static void sched_slave(void)
>
> pcpu_schedule_unlock_irq(lock, cpu);
>
> - sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu), now);
> + sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu),
> + is_idle_unit(next) && !is_idle_unit(prev), now);
> }
>
> /*
> @@ -2075,7 +2140,8 @@ static void schedule(void)
> pcpu_schedule_unlock_irq(lock, cpu);
>
> vnext = sched_unit2vcpu_cpu(next, cpu);
> - sched_context_switch(vprev, vnext, now);
> + sched_context_switch(vprev, vnext,
> + !is_idle_unit(prev) && is_idle_unit(next), now);
> }
As a minor remark, I think between such constructs it would be good
if there was no difference, unless there's a reason to have one. Yet
if there was a reason, it surely would want to be spelled out.
> @@ -124,16 +129,22 @@ unsigned long get_stack_dump_bottom (unsigned long sp);
> # define CHECK_FOR_LIVEPATCH_WORK ""
> #endif
>
> -#define reset_stack_and_jump(__fn) \
> +#define switch_stack_and_jump(fn, instr) \
Is there any dependency on "instr" to just be a single instruction?
I'm inclined to ask for it to be named "extra" or some such.
> --- a/xen/include/asm-x86/smp.h
> +++ b/xen/include/asm-x86/smp.h
> @@ -76,6 +76,9 @@ void set_nr_sockets(void);
> /* Representing HT and core siblings in each socket. */
> extern cpumask_t **socket_cpumask;
>
> +#define get_cpu_current(cpu) \
> + (get_cpu_info_from_stack((unsigned long)stack_base[cpu])->current_vcpu)
I don't think this can go without a comment clarifying under what
(pretty narrow I think) conditions this is legitimate to use.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
` (47 preceding siblings ...)
2019-09-20 16:14 ` [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Jan Beulich
@ 2019-09-24 11:15 ` Sergey Dyasli
2019-09-24 11:17 ` Jürgen Groß
2019-09-24 17:29 ` Dario Faggioli
48 siblings, 2 replies; 161+ messages in thread
From: Sergey Dyasli @ 2019-09-24 11:15 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: sergey.dyasli@citrix.com >> Sergey Dyasli,
Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Robert VanVossen,
Dario Faggioli, Julien Grall, Igor Druzhinin, Josh Whitehead,
Meng Xu, Jan Beulich, Volodymyr Babchuk, Ian Jackson,
Roger Pau Monné
Hi Juergen,
After an extensive testing of your jgross1/sched-v3 branch in XenRT,
I'm happy to say that we've found no functional regressions so far
when running in the default (thread/cpu) mode.
Hopefully this gives some level of confidence to this series and the
plan about including it into 4.13 [1]
[1] RFC: Criteria for checking in core scheduling series
https://lore.kernel.org/xen-devel/97e1bfe4-3383-ff1d-bf61-48b8aa63bb2c@citrix.com/
Thanks,
Sergey
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support
2019-09-24 11:15 ` Sergey Dyasli
@ 2019-09-24 11:17 ` Jürgen Groß
2019-09-24 17:29 ` Dario Faggioli
1 sibling, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 11:17 UTC (permalink / raw)
To: Sergey Dyasli, xen-devel
Cc: IgorDruzhinin, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Tim Deegan,
Ian Jackson, RobertVanVossen, Dario Faggioli, Julien Grall,
Josh Whitehead, Meng Xu, Jan Beulich, Volodymyr Babchuk,
Roger Pau Monné
On 24.09.19 13:15, Sergey Dyasli wrote:
> Hi Juergen,
>
> After an extensive testing of your jgross1/sched-v3 branch in XenRT,
> I'm happy to say that we've found no functional regressions so far
> when running in the default (thread/cpu) mode.
>
> Hopefully this gives some level of confidence to this series and the
> plan about including it into 4.13 [1]
>
> [1] RFC: Criteria for checking in core scheduling series
> https://lore.kernel.org/xen-devel/97e1bfe4-3383-ff1d-bf61-48b8aa63bb2c@citrix.com/
Thank you very much for your efforts and the confirmation!
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource
2019-09-19 15:27 ` Jan Beulich
@ 2019-09-24 11:41 ` Jürgen Groß
2019-09-24 12:08 ` Jan Beulich
2019-09-24 17:11 ` Dario Faggioli
0 siblings, 2 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 11:41 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Dario Faggioli, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Roger Pau Monné
On 19.09.19 17:27, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> This prepares support of larger scheduling granularities, e.g. core
>> scheduling.
>>
>> While at it move sched_has_urgent_vcpu() from include/asm-x86/cpuidle.h
>> into sched.h removing the need for including sched-if.h in cpuidle.h.
>> For that purpose remobe urgent_count from the scheduler private data
>> and make it a plain percpu variable.
>>
>> Signed-off-by: Juergen Gross <jgross@suse.com>
>
> Fundamentally
> Reviewed-by: Jan Beulich <jbeulich@suse.com>
> but a couple of remarks:
>
>> @@ -643,7 +643,7 @@ static spinlock_t *
>> a653_switch_sched(struct scheduler *new_ops, unsigned int cpu,
>> void *pdata, void *vdata)
>> {
>> - struct schedule_data *sd = &per_cpu(schedule_data, cpu);
>> + struct sched_resource *sd = get_sched_res(cpu);
>
> I can understand why you keep "sd" as a name here and in similar
> cases. But ...
>
>> @@ -3881,6 +3881,7 @@ csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu,
>> {
>> struct csched2_private *prv = csched2_priv(new_ops);
>> struct csched2_unit *svc = vdata;
>> + struct sched_resource *sd = get_sched_res(cpu);
>
> ... here (and in at least one more place) you introduce a new
> variable. Wouldn't this better be named e.g. "sr"? Furthermore
> you use it just once ...
>
>> @@ -3906,7 +3907,7 @@ csched2_switch_sched(struct scheduler *new_ops, unsigned int cpu,
>> * this scheduler, and so it's safe to have taken it /before/ our
>> * private global lock.
>> */
>> - ASSERT(per_cpu(schedule_data, cpu).schedule_lock != &prv->rqd[rqi].lock);
>> + ASSERT(sd->schedule_lock != &prv->rqd[rqi].lock);
>
> ... here; it doesn't seem worthwhile here, but I guess
> subsequent changes make more use of it?
In fact they don't. I'll remove it here.
Regarding to rename "sd" to "sr": I agree this would be a sensible
change. OTOH I'd like to be consistent, so I'd like to defer that to
the planned scheduling cleanup series.
>
>> @@ -393,7 +395,7 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor)
>> /* Idle VCPUs are scheduled immediately, so don't put them in runqueue. */
>> if ( is_idle_domain(d) )
>> {
>> - per_cpu(schedule_data, v->processor).curr = unit;
>> + get_sched_res(v->processor)->curr = unit;
>
> As long as it's a macro (see below), why not use curr_on_cpu() here?
There will be another sched_resource initialization added here
later. This makes it more obvious.
>
>> @@ -1916,7 +1917,7 @@ void __init scheduler_init(void)
>> idle_domain->max_vcpus = nr_cpu_ids;
>> if ( vcpu_create(idle_domain, 0, 0) == NULL )
>> BUG();
>> - this_cpu(schedule_data).curr = idle_vcpu[0]->sched_unit;
>> + get_sched_res(0)->curr = idle_vcpu[0]->sched_unit;
>
> Hmm, yet another plain 0. But yes, there are quite a few of them
> here already, so one more doesn't really matter.
Yes, we should add a boot_cpu variable. But not in this series.
>
>> --- a/xen/include/xen/sched-if.h
>> +++ b/xen/include/xen/sched-if.h
>> @@ -33,22 +33,19 @@ extern int sched_ratelimit_us;
>> * For cache betterness, keep the actual lock in the same cache area
>> * as the rest of the struct. Just have the scheduler point to the
>> * one it wants (This may be the one right in front of it).*/
>> -struct schedule_data {
>> +struct sched_resource {
>> spinlock_t *schedule_lock,
>> _lock;
>> struct sched_unit *curr;
>> void *sched_priv;
>> struct timer s_timer; /* scheduling timer */
>> - atomic_t urgent_count; /* how many urgent vcpus */
>> -};
>> -
>> -#define curr_on_cpu(c) (per_cpu(schedule_data, c).curr)
>>
>> -struct sched_resource {
>> - unsigned int master_cpu; /* Cpu with lowest id in scheduling resource. */
>> + /* Cpu with lowest id in scheduling resource. */
>> + unsigned int master_cpu;
>> };
>>
>> -DECLARE_PER_CPU(struct schedule_data, schedule_data);
>> +#define curr_on_cpu(c) (get_sched_res(c)->curr)
>
> By moving this a few lines down if could become an inline function
> as it seems, if (see above) its use as an lvalue is not intended.
I like that idea. Will change to inline function.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 09/47] xen/sched: move some per-vcpu items to struct sched_unit
2019-09-19 15:38 ` Jan Beulich
@ 2019-09-24 11:44 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 11:44 UTC (permalink / raw)
To: Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, Meng Xu, xen-devel, Dario Faggioli
On 19.09.19 17:38, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> Affinities are scheduler specific attributes, they should be per
>> scheduling unit. So move all affinity related fields in struct vcpu
>> to struct sched_unit. While at it switch affinity related functions in
>> sched-if.h to use a pointer to sched_unit instead to vcpu as parameter.
>>
>> The affinity_broken flag must be kept per vcpu as it is related to
>> guest actions on specific vcpus. When support of multiple vcpus per
>> sched_unit is being added, a unit is regarded as being subject to
>> "broken affinity" when any of its vcpus has the affinity_broken flag
>> set.
>>
>> Signed-off-by: Juergen Gross <jgross@suse.com>
>> ---
>> V2:
>> - move affinity_broken back to struct vcpu (Jan Beulich)
>> - print affinities only once per unit (Jan Beulich)
>> ---
>> xen/common/domain.c | 15 ++------
>> xen/common/domctl.c | 13 ++++---
>> xen/common/keyhandler.c | 58 ++++++++++++++++--------------
>
> Acked-by: Jan Beulich <jbeulich@suse.com>
> with one minor remark:
>
>> --- a/xen/common/keyhandler.c
>> +++ b/xen/common/keyhandler.c
>> @@ -251,6 +251,7 @@ static void reboot_machine(unsigned char key, struct cpu_user_regs *regs)
>> static void dump_domains(unsigned char key)
>> {
>> struct domain *d;
>> + struct sched_unit *unit;
>> struct vcpu *v;
>> s_time_t now = NOW();
>
> I can see how it would look a little odd here because of the
> neighboring variables, but generally speaking the new one should
> be pointer to const (and the old ones should have been, too,
> afaict).
Yes. Will change unit for now and the others in - you might have guessed
that already - the ever growing scheduling cleanup series (yes, I'm
noting the topics for that series).
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 10/47] xen/sched: add scheduler helpers hiding vcpu
2019-09-19 15:45 ` Jan Beulich
@ 2019-09-24 11:46 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 11:46 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 19.09.19 17:45, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> Add the following helpers using a sched_unit as input instead of a
>> vcpu:
>>
>> - is_idle_unit() similar to is_idle_vcpu()
>> - is_unit_online() similar to is_vcpu_online() (returns true when any
>> of its vcpus is online)
>> - unit_runnable() like vcpu_runnable() (returns true if any of its
>> vcpus is runnable)
>> - sched_set_res() to set the current scheduling resource of a unit
>> - sched_unit_cpu() to get the current processor of a unit (returns
>> the master_cpu of the scheduling resource of a unit)
>
> And hence perhaps better sched_unit_master() or sched_unit_master_cpu()?
Yes, sched_unit_master() is fine.
>
>> - sched_{set|clear}_pause_flags[_atomic]() to modify pause_flags of the
>> associated vcpu(s) (modifies the pause_flags of all vcpus of the
>> unit)
>
> I continue to think that it would have been better to have all of
> these have their loops right from the beginning. But it'll be the
> scheduler maintainers anyway to ack (or not) the patch in its
> current shape.
Dario has already mentioned he'd like that, too. So I'll do it.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit
2019-09-19 15:53 ` Jan Beulich
@ 2019-09-24 11:47 ` Jürgen Groß
2019-09-24 12:00 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 11:47 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, Meng Xu, xen-devel
On 19.09.19 17:53, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> @@ -1673,8 +1676,10 @@ static void schedule(void)
>> * switch, else lost_records resume will not work properly.
>> */
>>
>> - ASSERT(!next->is_running);
>> + ASSERT(!next->sched_unit->is_running);
>> next->is_running = 1;
>> + next->sched_unit->is_running = 1;
>
> Nit: The new field is of type bool, and hence you should write true
> and false into it. This may look odd next to the 1 above, but by
> the end of the series the two won't sit next to each other anymore.
Indeed. And making vcpu->is_running a bool is another item on my list
for the cleanup.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 23/47] xen/sched: switch sched_move_irqs() to take sched_unit as parameter
2019-09-20 14:34 ` Jan Beulich
@ 2019-09-24 11:55 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 11:55 UTC (permalink / raw)
To: Jan Beulich; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 20.09.19 16:34, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> --- a/xen/common/schedule.c
>> +++ b/xen/common/schedule.c
>> @@ -474,12 +474,20 @@ int sched_init_vcpu(struct vcpu *v)
>> return 0;
>> }
>>
>> -static void sched_move_irqs(struct vcpu *v)
>> +static void vcpu_move_irqs(struct vcpu *v)
>> {
>> arch_move_irqs(v);
>> evtchn_move_pirqs(v);
>> }
>>
>> +static void sched_move_irqs(struct sched_unit *unit)
>
> I think the parameter could be constified.
Yes.
>
>> @@ -1736,7 +1744,7 @@ static void schedule(void)
>> stop_timer(&prev->vcpu_list->periodic_timer);
>>
>> if ( next_slice.migrated )
>> - sched_move_irqs(next->vcpu_list);
>> + vcpu_move_irqs(next->vcpu_list);
>
> Why is this not also sched_move_irqs(), at which point there wouldn't
> be a need for a separate vcpu_move_irqs() afaict?
This is the place where a single vcpu is scheduled on a new cpu.
The places where sched_move_irqs() is being used is where a unit has
been forced to other cpu(s).
At the end of the series this is much more clear.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 35/47] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 35/47] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware Juergen Gross
@ 2019-09-24 11:55 ` Jan Beulich
2019-09-25 13:07 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 11:55 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 14.09.2019 10:52, Juergen Gross wrote:
> --- a/xen/common/schedule.c
> +++ b/xen/common/schedule.c
> @@ -724,8 +724,10 @@ void sched_destroy_domain(struct domain *d)
> }
> }
>
> -void vcpu_sleep_nosync_locked(struct vcpu *v)
> +static void vcpu_sleep_nosync_locked(struct vcpu *v)
> {
> + struct sched_unit *unit = v->sched_unit;
> +
> ASSERT(spin_is_locked(get_sched_res(v->processor)->schedule_lock));
>
> if ( likely(!vcpu_runnable(v)) )
> @@ -733,7 +735,14 @@ void vcpu_sleep_nosync_locked(struct vcpu *v)
> if ( v->runstate.state == RUNSTATE_runnable )
> vcpu_runstate_change(v, RUNSTATE_offline, NOW());
>
> - sched_sleep(vcpu_scheduler(v), v->sched_unit);
> + if ( likely(!unit_runnable(unit)) )
> + sched_sleep(vcpu_scheduler(v), unit);
unit_scheduler(unit) (also elsewhere)?
> @@ -765,16 +774,22 @@ void vcpu_wake(struct vcpu *v)
> {
> unsigned long flags;
> spinlock_t *lock;
> + struct sched_unit *unit = v->sched_unit;
>
> TRACE_2D(TRC_SCHED_WAKE, v->domain->domain_id, v->vcpu_id);
>
> - lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
> + lock = unit_schedule_lock_irqsave(unit, &flags);
>
> if ( likely(vcpu_runnable(v)) )
> {
> if ( v->runstate.state >= RUNSTATE_blocked )
> vcpu_runstate_change(v, RUNSTATE_runnable, NOW());
> - sched_wake(vcpu_scheduler(v), v->sched_unit);
> + sched_wake(vcpu_scheduler(v), unit);
Is this correct / necessary when the unit is not asleep as a whole?
After all the corresponding sched_sleep() further up is called
conditionally only.
> @@ -1998,6 +2013,62 @@ static void sched_context_switch(struct vcpu *vprev, struct vcpu *vnext,
> context_switch(vprev, vnext);
> }
>
> +/*
> + * Force a context switch of a single vcpu of an unit.
> + * Might be called either if a vcpu of an already running unit is woken up
> + * or if a vcpu of a running unit is put asleep with other vcpus of the same
> + * unit still running.
> + */
> +static struct vcpu *sched_force_context_switch(struct vcpu *vprev,
> + struct vcpu *v,
> + int cpu, s_time_t now)
unsigned int cpu? (Aiui it's suppose to equal smp_processor_id()
anyway.)
> +{
> + v->force_context_switch = false;
> +
> + if ( vcpu_runnable(v) == v->is_running )
> + return NULL;
This and other NULL returns suggest that the comment ahead of the
function might better state what the return value here is / means.
> + if ( vcpu_runnable(v) )
> + {
> + if ( is_idle_vcpu(vprev) )
> + {
> + vcpu_runstate_change(vprev, RUNSTATE_runnable, now);
> + vprev->sched_unit = get_sched_res(cpu)->sched_unit_idle;
> + }
> + vcpu_runstate_change(v, RUNSTATE_running, now);
> + }
> + else
> + {
> + /* Make sure not to switch last vcpu of an unit away. */
> + if ( unit_running(v->sched_unit) == 1 )
> + return NULL;
> +
> + v->new_state = vcpu_runstate_blocked(v);
> + vcpu_runstate_change(v, v->new_state, now);
> + v = sched_unit2vcpu_cpu(vprev->sched_unit, cpu);
> + if ( v != vprev )
> + {
> + if ( is_idle_vcpu(vprev) )
> + {
> + vcpu_runstate_change(vprev, RUNSTATE_runnable, now);
> + vprev->sched_unit = get_sched_res(cpu)->sched_unit_idle;
> + }
> + else
> + {
> + v->sched_unit = vprev->sched_unit;
> + vcpu_runstate_change(v, RUNSTATE_running, now);
> + }
> + }
> + }
> +
> + v->is_running = 1;
Besides this wanting to use "true", how come this is unconditional
despite the function here being used for both waking and putting to
sleep of a vCPU?
> @@ -2067,9 +2160,29 @@ static void sched_slave(void)
>
> now = NOW();
>
> + v = unit2vcpu_cpu(prev, cpu);
> + if ( v && v->force_context_switch )
> + {
> + v = sched_force_context_switch(vprev, v, cpu, now);
> +
> + if ( v )
> + {
> + pcpu_schedule_unlock_irq(lock, cpu);
I can't figure what it is that guarantees that this unlock isn't
going to be followed ...
> + sched_context_switch(vprev, v, false, now);
> + }
> +
> + do_softirq = true;
> + }
> +
> if ( !prev->rendezvous_in_cnt )
> {
> pcpu_schedule_unlock_irq(lock, cpu);
... by another unlock here. Or wait - is sched_context_switch()
(and perhaps other functions involved there) lacking a "noreturn"
annotation?
> --- a/xen/include/xen/sched-if.h
> +++ b/xen/include/xen/sched-if.h
> @@ -100,6 +100,11 @@ static inline bool unit_runnable(const struct sched_unit *unit)
> return false;
> }
>
> +static inline int vcpu_runstate_blocked(struct vcpu *v)
const?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit
2019-09-24 11:47 ` Jürgen Groß
@ 2019-09-24 12:00 ` Jan Beulich
2019-09-24 12:34 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 12:00 UTC (permalink / raw)
To: Jürgen Groß
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, Meng Xu, xen-devel
On 24.09.2019 13:47, Jürgen Groß wrote:
> On 19.09.19 17:53, Jan Beulich wrote:
>> On 14.09.2019 10:52, Juergen Gross wrote:
>>> @@ -1673,8 +1676,10 @@ static void schedule(void)
>>> * switch, else lost_records resume will not work properly.
>>> */
>>>
>>> - ASSERT(!next->is_running);
>>> + ASSERT(!next->sched_unit->is_running);
>>> next->is_running = 1;
>>> + next->sched_unit->is_running = 1;
>>
>> Nit: The new field is of type bool, and hence you should write true
>> and false into it. This may look odd next to the 1 above, but by
>> the end of the series the two won't sit next to each other anymore.
>
> Indeed. And making vcpu->is_running a bool is another item on my list
> for the cleanup.
Is it? It's already bool afaics. It's just the values written to it
which aren't properly true / false.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 36/47] xen/sched: carve out freeing sched_unit memory into dedicated function
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 36/47] xen/sched: carve out freeing sched_unit memory into dedicated function Juergen Gross
@ 2019-09-24 12:04 ` Jan Beulich
2019-09-25 13:09 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 12:04 UTC (permalink / raw)
To: Juergen Gross; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 14.09.2019 10:52, Juergen Gross wrote:
> --- a/xen/common/schedule.c
> +++ b/xen/common/schedule.c
> @@ -351,26 +351,10 @@ static void sched_spin_unlock_double(spinlock_t *lock1, spinlock_t *lock2,
> spin_unlock_irqrestore(lock1, flags);
> }
>
> -static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
> +static void sched_free_unit_mem(struct sched_unit *unit)
> {
> struct sched_unit *prev_unit;
> struct domain *d = unit->domain;
> - struct vcpu *vunit;
> - unsigned int cnt = 0;
> -
> - /* Don't count to be released vcpu, might be not in vcpu list yet. */
> - for_each_sched_unit_vcpu ( unit, vunit )
> - if ( vunit != v )
> - cnt++;
> -
> - v->sched_unit = NULL;
> - unit->runstate_cnt[v->runstate.state]--;
> -
> - if ( cnt )
> - return;
> -
> - if ( unit->vcpu_list == v )
> - unit->vcpu_list = v->next_in_list;
>
> if ( d->sched_unit_list == unit )
> d->sched_unit_list = unit->next_in_list;
> @@ -393,6 +377,26 @@ static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
> xfree(unit);
> }
>
> +static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
> +{
> + struct vcpu *vunit;
> + unsigned int cnt = 0;
> +
> + /* Don't count to be released vcpu, might be not in vcpu list yet. */
> + for_each_sched_unit_vcpu ( unit, vunit )
> + if ( vunit != v )
> + cnt++;
> +
> + v->sched_unit = NULL;
> + unit->runstate_cnt[v->runstate.state]--;
> +
> + if ( unit->vcpu_list == v )
> + unit->vcpu_list = v->next_in_list;
> +
> + if ( !cnt )
> + sched_free_unit_mem(unit);
> +}
The entire sched_free_unit() is new code (starting from patch 3) - why
don't you arrange for the split right away, instead of moving code
around here?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource
2019-09-24 11:41 ` Jürgen Groß
@ 2019-09-24 12:08 ` Jan Beulich
2019-09-24 15:10 ` Jürgen Groß
2019-09-25 6:49 ` Jürgen Groß
2019-09-24 17:11 ` Dario Faggioli
1 sibling, 2 replies; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 12:08 UTC (permalink / raw)
To: Jürgen Groß
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Dario Faggioli, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Roger Pau Monné
On 24.09.2019 13:41, Jürgen Groß wrote:
> Regarding to rename "sd" to "sr": I agree this would be a sensible
> change. OTOH I'd like to be consistent, so I'd like to defer that to
> the planned scheduling cleanup series.
Seeing another introduction of "sd" in as late as patch 37, I really
wonder if this approach (and the resulting extra code churn) is
indeed better than naming at least new variable instances properly
right away.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 24/47] xen: switch from for_each_vcpu() to for_each_sched_unit()
2019-09-20 15:05 ` Jan Beulich
@ 2019-09-24 12:13 ` Jürgen Groß
2019-09-24 12:31 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 12:13 UTC (permalink / raw)
To: Jan Beulich, Joshua Whitehead, Robert VanVossen
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli
On 20.09.19 17:05, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> @@ -508,25 +515,27 @@ int sched_move_domain(struct domain *d, struct cpupool *c)
>> if ( IS_ERR(domdata) )
>> return PTR_ERR(domdata);
>>
>> - vcpu_priv = xzalloc_array(void *, d->max_vcpus);
>> - if ( vcpu_priv == NULL )
>> + /* TODO: fix array size with multiple vcpus per unit. */
>> + unit_priv = xzalloc_array(void *, d->max_vcpus);
>> + if ( unit_priv == NULL )
>> {
>> sched_free_domdata(c->sched, domdata);
>> return -ENOMEM;
>> }
>>
>> - for_each_vcpu ( d, v )
>> + unit_idx = 0;
>> + for_each_sched_unit ( d, unit )
>> {
>> - vcpu_priv[v->vcpu_id] = sched_alloc_vdata(c->sched, v->sched_unit,
>> - domdata);
>> - if ( vcpu_priv[v->vcpu_id] == NULL )
>> + unit_priv[unit_idx] = sched_alloc_vdata(c->sched, unit, domdata);
>> + if ( unit_priv[unit_idx] == NULL )
>> {
>> - for_each_vcpu ( d, v )
>> - xfree(vcpu_priv[v->vcpu_id]);
>> - xfree(vcpu_priv);
>> + for ( unit_idx = 0; unit_priv[unit_idx]; unit_idx++ )
>> + sched_free_vdata(c->sched, unit_priv[unit_idx]);
>
> This is an unexpected change from xfree() to sched_free_vdata(). If
> it really is correct, it should be mentioned in the description. I
> can see why this might be better from an abstract pov, but it's
> questionable whether arinc653's update_schedule_vcpus() really wants
> calling at this point (perhaps it does, as a653sched_alloc_vdata()
> also calls it).
Yes, I should put this change into an own patch at the beginning
of the series (or outside of it), as it is really a bug fix.
The data allocated via sched_alloc_vdata() is put into a list by the
arinc scheduler, so just xfree()ing it is clearly wrong.
>
> Josh, Robert: Besides this immediate aspect I also wonder whether
> said call is correct to make outside of a sched_priv->lock'ed
> region, when both other instances occur inside of one (and in one
> case immediately before an unlock, i.e. if the lock wasn't needed
> the two steps could well be re-ordered).
I guess a653sched_free_vdata() is missing the required locking.
I'll add that in the bugfix.
> Finally, at this point, shouldn't the functions and hooks (already)
> be named {alloc,free}_udata()?
Indeed they should.
>
>> @@ -896,18 +929,22 @@ void restore_vcpu_affinity(struct domain *d)
>> cpupool_domain_cpumask(d));
>> if ( cpumask_empty(cpumask_scratch_cpu(cpu)) )
>> {
>> - if ( v->affinity_broken )
>> + if ( sched_check_affinity_broken(unit) )
>> {
>> - sched_set_affinity(v, unit->cpu_hard_affinity_saved, NULL);
>> - v->affinity_broken = 0;
>> + /* Affinity settings of one vcpu are for the complete unit. */
>> + sched_set_affinity(unit->vcpu_list,
>> + unit->cpu_hard_affinity_saved, NULL);
>
> Yet despite the comment the function gets passed a struct vcpu *,
> and this doesn't look to change by the end of the series. Is there
> a reason for this?
Yes. sched_set_affinity() is used from outside of schedule.c (by
dom0_build.c).
>
>> @@ -950,17 +986,19 @@ int cpu_disable_scheduler(unsigned int cpu)
>>
>> for_each_domain_in_cpupool ( d, c )
>> {
>> - for_each_vcpu ( d, v )
>> + struct sched_unit *unit;
>> +
>> + for_each_sched_unit ( d, unit )
>> {
>> unsigned long flags;
>> - struct sched_unit *unit = v->sched_unit;
>> spinlock_t *lock = unit_schedule_lock_irqsave(unit, &flags);
>>
>> cpumask_and(&online_affinity, unit->cpu_hard_affinity, c->cpu_valid);
>> if ( cpumask_empty(&online_affinity) &&
>> cpumask_test_cpu(cpu, unit->cpu_hard_affinity) )
>> {
>> - if ( v->affinity_broken )
>> + /* TODO: multiple vcpus per unit. */
>> + if ( unit->vcpu_list->affinity_broken )
>
> Why not sched_check_affinity_broken(unit)? Quite possibly this would
> make the TODO item unnecessary?
Oh, indeed.
>
>> @@ -968,14 +1006,15 @@ int cpu_disable_scheduler(unsigned int cpu)
>> break;
>> }
>>
>> - printk(XENLOG_DEBUG "Breaking affinity for %pv\n", v);
>> + printk(XENLOG_DEBUG "Breaking affinity for %pv\n",
>> + unit->vcpu_list);
>>
>> - sched_set_affinity(v, &cpumask_all, NULL);
>> + sched_set_affinity(unit->vcpu_list, &cpumask_all, NULL);
>> }
>>
>> - if ( v->processor != cpu )
>> + if ( sched_unit_cpu(unit) != sched_get_resource_cpu(cpu) )
>
> Didn't you agree that this can be had cheaper? Quite likely my v2
> review remark was on a different instance, but the pattern ought
> to be relatively simple to find in the entire series (and by the
> end of the series there's one other instance in schedule.c ...
Will check again. Thanks for the reminder.
>
>> @@ -988,17 +1027,18 @@ int cpu_disable_scheduler(unsigned int cpu)
>> * * the scheduler will always find a suitable solution, or
>> * things would have failed before getting in here.
>> */
>> - vcpu_migrate_start(v);
>> + /* TODO: multiple vcpus per unit. */
>> + vcpu_migrate_start(unit->vcpu_list);
>> unit_schedule_unlock_irqrestore(lock, flags, unit);
>>
>> - vcpu_migrate_finish(v);
>> + vcpu_migrate_finish(unit->vcpu_list);
>>
>> /*
>> * The only caveat, in this case, is that if a vcpu active in
>> * the hypervisor isn't migratable. In this case, the caller
>> * should try again after releasing and reaquiring all locks.
>> */
>> - if ( v->processor == cpu )
>> + if ( sched_unit_cpu(unit) == sched_get_resource_cpu(cpu) )
>
> ... here; I didn't check other files).
>
>> @@ -1009,8 +1049,8 @@ int cpu_disable_scheduler(unsigned int cpu)
>> static int cpu_disable_scheduler_check(unsigned int cpu)
>> {
>> struct domain *d;
>> - struct vcpu *v;
>> struct cpupool *c;
>> + struct vcpu *v;
>
> Unnecessary change?
Yes.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 37/47] xen/sched: move per-cpu variable scheduler to struct sched_resource
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 37/47] xen/sched: move per-cpu variable scheduler to struct sched_resource Juergen Gross
@ 2019-09-24 12:16 ` Jan Beulich
2019-09-25 13:13 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 12:16 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 14.09.2019 10:52, Juergen Gross wrote:
> --- a/xen/common/sched_credit.c
> +++ b/xen/common/sched_credit.c
> @@ -352,9 +352,10 @@ DEFINE_PER_CPU(unsigned int, last_tickle_cpu);
> static inline void __runq_tickle(struct csched_unit *new)
> {
> unsigned int cpu = sched_unit_cpu(new->unit);
> + struct sched_resource *sd = get_sched_res(cpu);
> struct sched_unit *unit = new->unit;
> struct csched_unit * const cur = CSCHED_UNIT(curr_on_cpu(cpu));
> - struct csched_private *prv = CSCHED_PRIV(per_cpu(scheduler, cpu));
> + struct csched_private *prv = CSCHED_PRIV(sd->scheduler);
Is the single use "sd" (and, as mentioned elsewhere, mis-named)
really worth it? (Applicable further down as well.)
> @@ -931,7 +932,8 @@ csched_unit_acct(struct csched_private *prv, unsigned int cpu)
> {
> struct sched_unit *currunit = current->sched_unit;
> struct csched_unit * const svc = CSCHED_UNIT(currunit);
> - const struct scheduler *ops = per_cpu(scheduler, cpu);
> + struct sched_resource *sd = get_sched_res(cpu);
> + const struct scheduler *ops = sd->scheduler;
>
> ASSERT( sched_unit_cpu(currunit) == cpu );
> ASSERT( svc->sdom != NULL );
> @@ -987,8 +989,7 @@ csched_unit_acct(struct csched_private *prv, unsigned int cpu)
> * idlers. But, if we are here, it means there is someone running
> * on it, and hence the bit must be zero already.
> */
> - ASSERT(!cpumask_test_cpu(cpu,
> - CSCHED_PRIV(per_cpu(scheduler, cpu))->idlers));
> + ASSERT(!cpumask_test_cpu(cpu, CSCHED_PRIV(sd->scheduler)->idlers));
While at the first glance "sd" is used twice here, this 2nd use is
actually unnecessary - "cpu" hasn't changed from the beginning of
the function afaics, and hence "ops" could be used here.
Preferably with the suggested adjustments (but final judgement is
with the scheduler maintainers anyway)
Reviewed-by: Jan Beulich <jbeulich@suse.com>
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 24/47] xen: switch from for_each_vcpu() to for_each_sched_unit()
2019-09-24 12:13 ` Jürgen Groß
@ 2019-09-24 12:31 ` Jan Beulich
2019-09-24 15:00 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 12:31 UTC (permalink / raw)
To: Jürgen Groß
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Dario Faggioli, Julien Grall, Joshua Whitehead, xen-devel
On 24.09.2019 14:13, Jürgen Groß wrote:
> On 20.09.19 17:05, Jan Beulich wrote:
>> On 14.09.2019 10:52, Juergen Gross wrote:
>>> @@ -896,18 +929,22 @@ void restore_vcpu_affinity(struct domain *d)
>>> cpupool_domain_cpumask(d));
>>> if ( cpumask_empty(cpumask_scratch_cpu(cpu)) )
>>> {
>>> - if ( v->affinity_broken )
>>> + if ( sched_check_affinity_broken(unit) )
>>> {
>>> - sched_set_affinity(v, unit->cpu_hard_affinity_saved, NULL);
>>> - v->affinity_broken = 0;
>>> + /* Affinity settings of one vcpu are for the complete unit. */
>>> + sched_set_affinity(unit->vcpu_list,
>>> + unit->cpu_hard_affinity_saved, NULL);
>>
>> Yet despite the comment the function gets passed a struct vcpu *,
>> and this doesn't look to change by the end of the series. Is there
>> a reason for this?
>
> Yes. sched_set_affinity() is used from outside of schedule.c (by
> dom0_build.c).
How about changing the call there then, rather than having confusing
code here?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit
2019-09-24 12:00 ` Jan Beulich
@ 2019-09-24 12:34 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 12:34 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, Meng Xu, xen-devel
On 24.09.19 14:00, Jan Beulich wrote:
> On 24.09.2019 13:47, Jürgen Groß wrote:
>> On 19.09.19 17:53, Jan Beulich wrote:
>>> On 14.09.2019 10:52, Juergen Gross wrote:
>>>> @@ -1673,8 +1676,10 @@ static void schedule(void)
>>>> * switch, else lost_records resume will not work properly.
>>>> */
>>>>
>>>> - ASSERT(!next->is_running);
>>>> + ASSERT(!next->sched_unit->is_running);
>>>> next->is_running = 1;
>>>> + next->sched_unit->is_running = 1;
>>>
>>> Nit: The new field is of type bool, and hence you should write true
>>> and false into it. This may look odd next to the 1 above, but by
>>> the end of the series the two won't sit next to each other anymore.
>>
>> Indeed. And making vcpu->is_running a bool is another item on my list
>> for the cleanup.
>
> Is it? It's already bool afaics. It's just the values written to it
> which aren't properly true / false.
Saw that after sending my mail. So 0/1 -> false/true is the item to do.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 38/47] xen/sched: move per-cpu variable cpupool to struct sched_resource
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 38/47] xen/sched: move per-cpu variable cpupool " Juergen Gross
@ 2019-09-24 13:10 ` Jan Beulich
2019-09-25 13:17 ` Jürgen Groß
2019-09-26 9:09 ` Dario Faggioli
1 sibling, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 13:10 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, Meng Xu, xen-devel
On 14.09.2019 10:52, Juergen Gross wrote:
> Having a pointer to struct cpupool in struct sched_resource instead
> of per cpu is enough.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
Technically / mechanically
Reviewed-by: Jan Beulich <jbeulich@suse.com>
However, I'm confused by what appears to be a resulting chicken-and-
egg problem when considering the plan of allowing different
granularities in different cpupools. Perhaps I'm either mis-
remembering that plan, or it's not clear to me how data would get
structured in that case.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 40/47] xen/sched: prepare per-cpupool scheduling granularity
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 40/47] xen/sched: prepare per-cpupool scheduling granularity Juergen Gross
@ 2019-09-24 13:34 ` Jan Beulich
2019-09-25 13:31 ` Jürgen Groß
2019-09-26 9:41 ` Dario Faggioli
0 siblings, 2 replies; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 13:34 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 14.09.2019 10:52, Juergen Gross wrote:
> --- a/xen/common/cpupool.c
> +++ b/xen/common/cpupool.c
> @@ -175,6 +175,8 @@ static struct cpupool *cpupool_create(
> return NULL;
> }
> }
> + c->granularity = sched_granularity;
> + c->opt_granularity = opt_sched_granularity;
>
> *q = c;
>
> diff --git a/xen/common/schedule.c b/xen/common/schedule.c
> index e5b7678dc0..b3c1aa0821 100644
> --- a/xen/common/schedule.c
> +++ b/xen/common/schedule.c
> @@ -56,7 +56,8 @@ int sched_ratelimit_us = SCHED_DEFAULT_RATELIMIT_US;
> integer_param("sched_ratelimit_us", sched_ratelimit_us);
>
> /* Number of vcpus per struct sched_unit. */
> -static unsigned int __read_mostly sched_granularity = 1;
> +enum sched_gran __read_mostly opt_sched_granularity = SCHED_GRAN_cpu;
> +unsigned int __read_mostly sched_granularity = 1;
Seeing the replacements you do further down, are these variables
needed at all anymore outside of cpupool.c? If not, they should
probably move there, and remain / become static?
> --- a/xen/include/xen/sched-if.h
> +++ b/xen/include/xen/sched-if.h
> @@ -25,6 +25,15 @@ extern int sched_ratelimit_us;
> /* Scheduling resource mask. */
> extern const cpumask_t *sched_res_mask;
>
> +/* Number of vcpus per struct sched_unit. */
> +enum sched_gran {
> + SCHED_GRAN_cpu,
> + SCHED_GRAN_core,
> + SCHED_GRAN_socket
> +};
Seeing the almost absurd arrangement on my AMD Fam17 system (128 CPUs
per Credit2 runqueue, for a total of two runqueues) I really wonder
whether there shouldn't be a plan for a further intermediate
granularity between "core" and "socket". The other day I did notice
Linux has gained the concept of "die", which would bring the
arrangement to a more reasonable 8 runqueues of 32 CPUs each on this
system. (I'm taking Credit2 as a reference here only.)
> @@ -532,6 +542,8 @@ struct cpupool
> struct cpupool *next;
> struct scheduler *sched;
> atomic_t refcnt;
> + unsigned int granularity;
> + enum sched_gran opt_granularity;
I'd like to suggest to avoid introducing opt_* identifiers not
directly driven by command line options. That'll just end up
confusing people. I have to admit I'm having trouble coming up with
good names for both fields, so I'd like to ask whether you really
need both - isn't what's called "granularity" above a function of
"opt_granularity"? Or alternatively couldn't what's named
"granularity" now be always taken from struct sched_resource? I
take it that within a pool all struct sched_resource instances
would have the same numeric granularity value. And I further take
it that struct sched_resource instances won't freely move between
cpupools (and hence could e.g. be associated with their pool on
linked list, the head of which lives in struct cpupool).
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 43/47] xen/sched: support multiple cpus per scheduling resource
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 43/47] xen/sched: support multiple cpus per scheduling resource Juergen Gross
@ 2019-09-24 13:49 ` Jan Beulich
2019-09-25 13:39 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 13:49 UTC (permalink / raw)
To: Juergen Gross
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 14.09.2019 10:52, Juergen Gross wrote:
> --- a/xen/common/schedule.c
> +++ b/xen/common/schedule.c
> @@ -59,7 +59,7 @@ integer_param("sched_ratelimit_us", sched_ratelimit_us);
> enum sched_gran __read_mostly opt_sched_granularity = SCHED_GRAN_cpu;
> unsigned int __read_mostly sched_granularity = 1;
> bool __read_mostly sched_disable_smt_switching;
> -const cpumask_t *sched_res_mask = &cpumask_all;
> +cpumask_var_t sched_res_mask;
For a non-automatic variable it might be even easier to have it
be cpumask_t?
> @@ -2401,6 +2407,8 @@ static int cpu_schedule_up(unsigned int cpu)
> /* We start with cpu granularity. */
> sd->granularity = 1;
>
> + cpumask_set_cpu(cpu, sched_res_mask);
I'm missing the clearing counterpart.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 25/47] xen/sched: add runstate counters to struct sched_unit
2019-09-20 15:27 ` Jan Beulich
@ 2019-09-24 13:50 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 13:50 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 20.09.19 17:27, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> @@ -368,7 +372,7 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
>> unit->vcpu_list = v;
>> unit->unit_id = v->vcpu_id;
>> unit->domain = d;
>> - v->sched_unit = unit;
>> + unit->runstate_cnt[v->runstate.state]++;
>>
>> for ( prev_unit = &d->sched_unit_list; *prev_unit;
>> prev_unit = &(*prev_unit)->next_in_list )
>> @@ -384,6 +388,8 @@ static struct sched_unit *sched_alloc_unit(struct vcpu *v)
>> !zalloc_cpumask_var(&unit->cpu_soft_affinity) )
>> goto fail;
>>
>> + v->sched_unit = unit;
>> +
>> return unit;
>>
>> fail:
>
> Is this movement of the assignment something which really belongs
> here, rather than in some earlier patch (perhaps the one actually
> introducing it)?
It certainly should be part of an earlier patch.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 28/47] xen/sched: add code to sync scheduling of all vcpus of a sched unit
2019-09-20 16:08 ` Jan Beulich
@ 2019-09-24 14:14 ` Jürgen Groß
2019-09-24 14:39 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 14:14 UTC (permalink / raw)
To: Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli, Volodymyr Babchuk,
Roger Pau Monné
On 20.09.19 18:08, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> --- a/xen/common/schedule.c
>> +++ b/xen/common/schedule.c
>> @@ -55,6 +55,9 @@ boolean_param("sched_smt_power_savings", sched_smt_power_savings);
>> int sched_ratelimit_us = SCHED_DEFAULT_RATELIMIT_US;
>> integer_param("sched_ratelimit_us", sched_ratelimit_us);
>>
>> +/* Number of vcpus per struct sched_unit. */
>> +static unsigned int __read_mostly sched_granularity = 1;
>
> Didn't you indicate earlier that this would be a per-pool property?
> Or was that just a longer term plan?
That was planned for later.
>
>> +/*
>> + * Rendezvous before taking a scheduling decision.
>> + * Called with schedule lock held, so all accesses to the rendezvous counter
>> + * can be normal ones (no atomic accesses needed).
>> + * The counter is initialized to the number of cpus to rendezvous initially.
>> + * Each cpu entering will decrement the counter. In case the counter becomes
>> + * zero do_schedule() is called and the rendezvous counter for leaving
>> + * context_switch() is set. All other members will wait until the counter is
>> + * becoming zero, dropping the schedule lock in between.
>> + */
>
> This recurring lock/unlock is liable to cause a massive cache line
> ping-pong, especially for socket or node scheduling. Instead of
> just a cpu_relax() between the main unlock and re-lock, could there
> perhaps be lock-less checks to determine whether there's any point
> at all re-acquiring the lock?
Hmm, this is certainly an idea for improvement.
I will think about that and in case I can come up with something I'll
send either a followup patch or include it in the series, depending on
the complexity of the solution.
>
>> +static void schedule(void)
>> +{
>> + struct vcpu *vnext, *vprev = current;
>> + struct sched_unit *prev = vprev->sched_unit, *next = NULL;
>> + s_time_t now;
>> + struct sched_resource *sd;
>> + spinlock_t *lock;
>> + int cpu = smp_processor_id();
>> +
>> + ASSERT_NOT_IN_ATOMIC();
>> +
>> + SCHED_STAT_CRANK(sched_run);
>> +
>> + sd = get_sched_res(cpu);
>> +
>> + lock = pcpu_schedule_lock_irq(cpu);
>> +
>> + if ( prev->rendezvous_in_cnt )
>> + {
>> + /*
>> + * We have a race: sched_slave() should be called, so raise a softirq
>> + * in order to re-enter schedule() later and call sched_slave() now.
>> + */
>> + pcpu_schedule_unlock_irq(lock, cpu);
>> +
>> + raise_softirq(SCHEDULE_SOFTIRQ);
>> + return sched_slave();
>> + }
>> +
>> + now = NOW();
>> +
>> + stop_timer(&sd->s_timer);
>
> Is the order of these two relevant? A while ago there were a couple
> of changes moving such NOW() invocations past anything that may take
> non-negligible time, to make accounting as accurate as possible.
No, I don't think the order is relevant. I can swap them.
>
>> --- a/xen/include/xen/softirq.h
>> +++ b/xen/include/xen/softirq.h
>> @@ -4,6 +4,7 @@
>> /* Low-latency softirqs come first in the following list. */
>> enum {
>> TIMER_SOFTIRQ = 0,
>> + SCHED_SLAVE_SOFTIRQ,
>> SCHEDULE_SOFTIRQ,
>> NEW_TLBFLUSH_CLOCK_PERIOD_SOFTIRQ,
>> RCU_SOFTIRQ,
>
> Seeing the comment, is the insertion you do as well as the pre-
> existing placement of SCHEDULE_SOFTIRQ still appropriate with
> the rendezvous-ing you introduce?
Putting SCHED_SLAVE_SOFTIRQ before SCHEDULE_SOFTIRQ is done on purpose,
as I want slave events to have higher priority than normal schedule
events.
Whether both want to be at that place or should be moved is something
which should be considered carefully. Is it okay to postpone that
question?
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 29/47] xen/sched: introduce unit_runnable_state()
2019-09-23 15:24 ` Jan Beulich
@ 2019-09-24 14:25 ` Jürgen Groß
2019-09-24 14:45 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 14:25 UTC (permalink / raw)
To: Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Tim Deegan, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Dario Faggioli
On 23.09.19 17:24, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> Today the vcpu runstate of a new scheduled vcpu is always set to
>> "running" even if at that time vcpu_runnable() is already returning
>> false due to a race (e.g. with pausing the vcpu).
>
> I can see this part, ...
>
>> With core scheduling this can no longer work as not all vcpus of a
>> schedule unit have to be "running" when being scheduled. So the vcpu's
>> new runstate has to be selected at the same time as the runnability of
>> the related schedule unit is probed.
>
> ... but I continue having trouble here. If it has been okay to set
> a vCPU no longer runnable to "running" nevertheless, why would the
> same not be true for schedule units? Part of the problem may be
> that ...
The difference is the need to drop the scheduling lock for doing the
rendezvous. vcpu_sleep() or vcpu_wake() could now interfere with
scheduling in a way which was not possible before.
>
>> --- a/xen/include/xen/sched-if.h
>> +++ b/xen/include/xen/sched-if.h
>> @@ -76,6 +76,29 @@ static inline bool unit_runnable(const struct sched_unit *unit)
>> return vcpu_runnable(unit->vcpu_list);
>
> ... this clearly still isn't doing the (I suppose) intended loop,
> and hence ...
>
>> }
>>
>> +static inline bool unit_runnable_state(const struct sched_unit *unit)
>> +{
>> + struct vcpu *v;
>> + bool runnable, ret = false;
>> +
>> + if ( is_idle_unit(unit) )
>> + return true;
>> +
>> + for_each_sched_unit_vcpu ( unit, v )
>> + {
>> + runnable = vcpu_runnable(v);
>> +
>> + v->new_state = runnable ? RUNSTATE_running
>> + : (v->pause_flags & VPF_blocked)
>> + ? RUNSTATE_blocked : RUNSTATE_offline;
>> +
>> + if ( runnable )
>> + ret = true;
>> + }
>> +
>> + return ret;
>> +}
>
> ... it's not obvious what the eventual difference between the two is
> going to be.
>
> Furthermore I think a function of the given name, returning bool, and
> taking a pointer to const deserves a comment as to the (possibly
> slightly unexpected) state change it does. This comment might then be
> worthwhile to extend to also outline the usage difference between it
> and its sibling above.
I'll add that.
>
>> --- a/xen/include/xen/sched.h
>> +++ b/xen/include/xen/sched.h
>> @@ -174,6 +174,7 @@ struct vcpu
>> XEN_GUEST_HANDLE(vcpu_runstate_info_compat_t) compat;
>> } runstate_guest; /* guest address */
>> #endif
>> + unsigned int new_state;
>
> Similarly I think it would be nice for this field to gain a brief
> comment as to its purpose compared to runstate.state.
Okay.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 28/47] xen/sched: add code to sync scheduling of all vcpus of a sched unit
2019-09-24 14:14 ` Jürgen Groß
@ 2019-09-24 14:39 ` Jan Beulich
0 siblings, 0 replies; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 14:39 UTC (permalink / raw)
To: Jürgen Groß
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli, Volodymyr Babchuk,
Roger Pau Monné
On 24.09.2019 16:14, Jürgen Groß wrote:
> On 20.09.19 18:08, Jan Beulich wrote:
>> On 14.09.2019 10:52, Juergen Gross wrote:
>>> --- a/xen/include/xen/softirq.h
>>> +++ b/xen/include/xen/softirq.h
>>> @@ -4,6 +4,7 @@
>>> /* Low-latency softirqs come first in the following list. */
>>> enum {
>>> TIMER_SOFTIRQ = 0,
>>> + SCHED_SLAVE_SOFTIRQ,
>>> SCHEDULE_SOFTIRQ,
>>> NEW_TLBFLUSH_CLOCK_PERIOD_SOFTIRQ,
>>> RCU_SOFTIRQ,
>>
>> Seeing the comment, is the insertion you do as well as the pre-
>> existing placement of SCHEDULE_SOFTIRQ still appropriate with
>> the rendezvous-ing you introduce?
>
> Putting SCHED_SLAVE_SOFTIRQ before SCHEDULE_SOFTIRQ is done on purpose,
> as I want slave events to have higher priority than normal schedule
> events.
>
> Whether both want to be at that place or should be moved is something
> which should be considered carefully. Is it okay to postpone that
> question?
Sure, it was just something that occurred to me when the comment
caught my attention.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-23 15:41 ` Jan Beulich
@ 2019-09-24 14:41 ` Jürgen Groß
2019-09-24 15:00 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 14:41 UTC (permalink / raw)
To: Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli
On 23.09.19 17:41, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> @@ -266,15 +267,16 @@ static inline void vcpu_runstate_change(
>> static inline void sched_unit_runstate_change(struct sched_unit *unit,
>> bool running, s_time_t new_entry_time)
>> {
>> - struct vcpu *v = unit->vcpu_list;
>> + struct vcpu *v;
>>
>> - if ( running )
>> - vcpu_runstate_change(v, v->new_state, new_entry_time);
>> - else
>> - vcpu_runstate_change(v,
>> - ((v->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
>> - (vcpu_runnable(v) ? RUNSTATE_runnable : RUNSTATE_offline)),
>> - new_entry_time);
>> + for_each_sched_unit_vcpu ( unit, v )
>> + if ( running )
>> + vcpu_runstate_change(v, v->new_state, new_entry_time);
>> + else
>> + vcpu_runstate_change(v,
>> + ((v->pause_flags & VPF_blocked) ? RUNSTATE_blocked :
>> + (vcpu_runnable(v) ? RUNSTATE_runnable : RUNSTATE_offline)),
>> + new_entry_time);
>> }
>
> As mentioned on v2 already, I'm having some difficulty seeing why a
> function like this one (and some of the sched-if.h changes here)
> couldn't be introduced with this loop you add now right away.
I'll have a look (as promised before).
>
> Seeing this change I'm also puzzled why ->new_state is used only in
> case "running" is true. Is there anything speaking against setting
> that field uniformly, and simply consuming it here in all cases?
There are multiple places where a not running vcpu changes state,
while a vcpu is put to "running" only by scheduling it. So setting
new_state would need to be done in multiple places right the same
way I'm doing the state change here.
>
>> @@ -1031,10 +1033,9 @@ int cpu_disable_scheduler(unsigned int cpu)
>> if ( cpumask_empty(&online_affinity) &&
>> cpumask_test_cpu(cpu, unit->cpu_hard_affinity) )
>> {
>> - /* TODO: multiple vcpus per unit. */
>> - if ( unit->vcpu_list->affinity_broken )
>> + if ( sched_check_affinity_broken(unit) )
>> {
>> - /* The vcpu is temporarily pinned, can't move it. */
>> + /* The unit is temporarily pinned, can't move it. */
>> unit_schedule_unlock_irqrestore(lock, flags, unit);
>
> Along these lines, wouldn't this change (and further related ones)
> belong into the patch introducing sched_check_affinity_broken()?
I already agreed on that.
>
>> @@ -1851,7 +1852,7 @@ void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
>> while ( atomic_read(&next->rendezvous_out_cnt) )
>> cpu_relax();
>> }
>> - else if ( vprev != vnext )
>> + else if ( vprev != vnext && sched_granularity == 1 )
>> context_saved(vprev);
>> }
>
> Would you mind helping me with understanding why this call is
> needed with a granularity of 1 only?
Otherwise it is done just a few lines up (granularity 1 will result
in rendezvous_out_cnt being zero).
>
>> --- a/xen/include/xen/sched-if.h
>> +++ b/xen/include/xen/sched-if.h
>> @@ -68,12 +68,32 @@ static inline bool is_idle_unit(const struct sched_unit *unit)
>>
>> static inline bool is_unit_online(const struct sched_unit *unit)
>> {
>> - return is_vcpu_online(unit->vcpu_list);
>> + struct vcpu *v;
>
> const?
Yes.
>
>> + for_each_sched_unit_vcpu ( unit, v )
>> + if ( is_vcpu_online(v) )
>> + return true;
>> +
>> + return false;
>> +}
>> +
>> +static inline unsigned int unit_running(const struct sched_unit *unit)
>> +{
>> + return unit->runstate_cnt[RUNSTATE_running];
>> }
>
> Is there really going to be a user needing the return value be a
> count, not just a boolean?
Yes. See patch 35.
>
>> static inline bool unit_runnable(const struct sched_unit *unit)
>> {
>> - return vcpu_runnable(unit->vcpu_list);
>> + struct vcpu *v;
>
> const?
Yes.
>
>> + if ( is_idle_unit(unit) )
>> + return true;
>> +
>> + for_each_sched_unit_vcpu ( unit, v )
>> + if ( vcpu_runnable(v) )
>> + return true;
>
> Isn't the loop going to yield true anyway for idle units? If so, is
> there a particular reason for the special casing of idle units up
> front here?
Didn't I explain that before? for_each_sched_unit_vcpu() for an idle
unit might end premature when one of the vcpus is running in another
unit (idle_vcpu->sched_unit != idle_unit).
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 31/47] xen/sched: modify cpupool_domain_cpumask() to be an unit mask
2019-09-23 15:44 ` Jan Beulich
@ 2019-09-24 14:45 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 14:45 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 23.09.19 17:44, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> cpupool_domain_cpumask() is used by scheduling to select cpus or to
>> iterate over cpus. In order to support scheduling units spanning
>> multiple cpus let cpupool_domain_cpumask() return a cpumask with only
>> one bit set per scheduling resource.
>
> I guess this renders the name misleading: How about a rename to
> cpupool_domain_master_cpumask(), along the lines of "master_cpu"?
Fine with me.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 29/47] xen/sched: introduce unit_runnable_state()
2019-09-24 14:25 ` Jürgen Groß
@ 2019-09-24 14:45 ` Jan Beulich
2019-09-24 14:48 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 14:45 UTC (permalink / raw)
To: Jürgen Groß
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Tim Deegan, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Dario Faggioli
On 24.09.2019 16:25, Jürgen Groß wrote:
> On 23.09.19 17:24, Jan Beulich wrote:
>> On 14.09.2019 10:52, Juergen Gross wrote:
>>> Today the vcpu runstate of a new scheduled vcpu is always set to
>>> "running" even if at that time vcpu_runnable() is already returning
>>> false due to a race (e.g. with pausing the vcpu).
>>
>> I can see this part, ...
>>
>>> With core scheduling this can no longer work as not all vcpus of a
>>> schedule unit have to be "running" when being scheduled. So the vcpu's
>>> new runstate has to be selected at the same time as the runnability of
>>> the related schedule unit is probed.
>>
>> ... but I continue having trouble here. If it has been okay to set
>> a vCPU no longer runnable to "running" nevertheless, why would the
>> same not be true for schedule units? Part of the problem may be
>> that ...
>
> The difference is the need to drop the scheduling lock for doing the
> rendezvous. vcpu_sleep() or vcpu_wake() could now interfere with
> scheduling in a way which was not possible before.
Ah, right. But this would be worth mentioning explicitly here to
help readers, wouldn't it? Doesn't need to be more than half a
sentence ...
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 31/47] xen/sched: modify cpupool_domain_cpumask() to be an unit mask
2019-09-23 15:50 ` Jan Beulich
@ 2019-09-24 14:46 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 14:46 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 23.09.19 17:50, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> --- a/xen/common/cpupool.c
>> +++ b/xen/common/cpupool.c
>> @@ -36,26 +36,35 @@ static DEFINE_SPINLOCK(cpupool_lock);
>>
>> DEFINE_PER_CPU(struct cpupool *, cpupool);
>>
>> +static void free_cpupool_struct(struct cpupool *c)
>> +{
>> + if ( c )
>> + {
>> + free_cpumask_var(c->res_valid);
>> + free_cpumask_var(c->cpu_valid);
>> + }
>> + xfree(c);
>> +}
>> +
>> static struct cpupool *alloc_cpupool_struct(void)
>> {
>> struct cpupool *c = xzalloc(struct cpupool);
>>
>> - if ( !c || !zalloc_cpumask_var(&c->cpu_valid) )
>> + if ( !c )
>> + return NULL;
>> +
>> + zalloc_cpumask_var(&c->cpu_valid);
>> + zalloc_cpumask_var(&c->res_valid);
>> +
>> + if ( !c->cpu_valid || !c->res_valid )
>
> I guess compilers (or other static analysis tools) may warn about
> this for NR_CPUS <= 2 * BITS_PER_LONG builds. The intention really
> is for you to check zalloc_cpumask_var()'s return value; perhaps
> it should get [have been] marked "__must_check".
Oh, thanks for noticing.
I'll change the usage.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 29/47] xen/sched: introduce unit_runnable_state()
2019-09-24 14:45 ` Jan Beulich
@ 2019-09-24 14:48 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 14:48 UTC (permalink / raw)
To: Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Tim Deegan, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Dario Faggioli
On 24.09.19 16:45, Jan Beulich wrote:
> On 24.09.2019 16:25, Jürgen Groß wrote:
>> On 23.09.19 17:24, Jan Beulich wrote:
>>> On 14.09.2019 10:52, Juergen Gross wrote:
>>>> Today the vcpu runstate of a new scheduled vcpu is always set to
>>>> "running" even if at that time vcpu_runnable() is already returning
>>>> false due to a race (e.g. with pausing the vcpu).
>>>
>>> I can see this part, ...
>>>
>>>> With core scheduling this can no longer work as not all vcpus of a
>>>> schedule unit have to be "running" when being scheduled. So the vcpu's
>>>> new runstate has to be selected at the same time as the runnability of
>>>> the related schedule unit is probed.
>>>
>>> ... but I continue having trouble here. If it has been okay to set
>>> a vCPU no longer runnable to "running" nevertheless, why would the
>>> same not be true for schedule units? Part of the problem may be
>>> that ...
>>
>> The difference is the need to drop the scheduling lock for doing the
>> rendezvous. vcpu_sleep() or vcpu_wake() could now interfere with
>> scheduling in a way which was not possible before.
>
> Ah, right. But this would be worth mentioning explicitly here to
> help readers, wouldn't it? Doesn't need to be more than half a
> sentence ...
Okay.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 24/47] xen: switch from for_each_vcpu() to for_each_sched_unit()
2019-09-24 12:31 ` Jan Beulich
@ 2019-09-24 15:00 ` Jürgen Groß
2019-09-24 15:04 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 15:00 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Dario Faggioli, Julien Grall, Joshua Whitehead, xen-devel
On 24.09.19 14:31, Jan Beulich wrote:
> On 24.09.2019 14:13, Jürgen Groß wrote:
>> On 20.09.19 17:05, Jan Beulich wrote:
>>> On 14.09.2019 10:52, Juergen Gross wrote:
>>>> @@ -896,18 +929,22 @@ void restore_vcpu_affinity(struct domain *d)
>>>> cpupool_domain_cpumask(d));
>>>> if ( cpumask_empty(cpumask_scratch_cpu(cpu)) )
>>>> {
>>>> - if ( v->affinity_broken )
>>>> + if ( sched_check_affinity_broken(unit) )
>>>> {
>>>> - sched_set_affinity(v, unit->cpu_hard_affinity_saved, NULL);
>>>> - v->affinity_broken = 0;
>>>> + /* Affinity settings of one vcpu are for the complete unit. */
>>>> + sched_set_affinity(unit->vcpu_list,
>>>> + unit->cpu_hard_affinity_saved, NULL);
>>>
>>> Yet despite the comment the function gets passed a struct vcpu *,
>>> and this doesn't look to change by the end of the series. Is there
>>> a reason for this?
>>
>> Yes. sched_set_affinity() is used from outside of schedule.c (by
>> dom0_build.c).
>
> How about changing the call there then, rather than having confusing
> code here?
I'm not sure that would be better.
What about dropping dom0_setup_vcpu() by calling vcpu_create() instead
and doing the pinning via a call to a new function in schedule.c after
having created all vcpus? In fact we could even do a common function
creating all but vcpu[0], doing the pinning and the updating the node
affinity. Probably this would want to be part of patch 20.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-24 14:41 ` Jürgen Groß
@ 2019-09-24 15:00 ` Jan Beulich
2019-09-24 15:09 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 15:00 UTC (permalink / raw)
To: Jürgen Groß
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli
On 24.09.2019 16:41, Jürgen Groß wrote:
> On 23.09.19 17:41, Jan Beulich wrote:
>> On 14.09.2019 10:52, Juergen Gross wrote:
>>> @@ -1851,7 +1852,7 @@ void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
>>> while ( atomic_read(&next->rendezvous_out_cnt) )
>>> cpu_relax();
>>> }
>>> - else if ( vprev != vnext )
>>> + else if ( vprev != vnext && sched_granularity == 1 )
>>> context_saved(vprev);
>>> }
>>
>> Would you mind helping me with understanding why this call is
>> needed with a granularity of 1 only?
>
> Otherwise it is done just a few lines up (granularity 1 will result
> in rendezvous_out_cnt being zero).
I.e. if is rendezvous_out_cnt is zero and vprev != vnext but
sched_granularity > 1 the call isn't needed? Why? At the end of
the series vcpu_context_saved() gets called in all cases; what's
conditional upon granularity being 1 there is the call to
unit_context_saved().
>>> + if ( is_idle_unit(unit) )
>>> + return true;
>>> +
>>> + for_each_sched_unit_vcpu ( unit, v )
>>> + if ( vcpu_runnable(v) )
>>> + return true;
>>
>> Isn't the loop going to yield true anyway for idle units? If so, is
>> there a particular reason for the special casing of idle units up
>> front here?
>
> Didn't I explain that before?
Quite possible; a good hint that a code comment wouldn't hurt.
> for_each_sched_unit_vcpu() for an idle
> unit might end premature when one of the vcpus is running in another
> unit (idle_vcpu->sched_unit != idle_unit).
Oh, that (v)->sched_unit == (i) in the construct is clearly unexpected.
Is this really still needed by the end of the series? I realize that
_some_ check is needed, but could this perhaps be arranged in a way
that you'd still hit all vCPU-s when using it on an idle unit, no
matter whether they're in use as a substitute in a "real" unit?
As to that construct - why is the parameter named "i" rather than "u"?
And why "e" in for_each_sched_unit()?
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 24/47] xen: switch from for_each_vcpu() to for_each_sched_unit()
2019-09-24 15:00 ` Jürgen Groß
@ 2019-09-24 15:04 ` Jan Beulich
0 siblings, 0 replies; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 15:04 UTC (permalink / raw)
To: Jürgen Groß
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Dario Faggioli, Julien Grall, Joshua Whitehead, xen-devel
On 24.09.2019 17:00, Jürgen Groß wrote:
> On 24.09.19 14:31, Jan Beulich wrote:
>> On 24.09.2019 14:13, Jürgen Groß wrote:
>>> On 20.09.19 17:05, Jan Beulich wrote:
>>>> On 14.09.2019 10:52, Juergen Gross wrote:
>>>>> @@ -896,18 +929,22 @@ void restore_vcpu_affinity(struct domain *d)
>>>>> cpupool_domain_cpumask(d));
>>>>> if ( cpumask_empty(cpumask_scratch_cpu(cpu)) )
>>>>> {
>>>>> - if ( v->affinity_broken )
>>>>> + if ( sched_check_affinity_broken(unit) )
>>>>> {
>>>>> - sched_set_affinity(v, unit->cpu_hard_affinity_saved, NULL);
>>>>> - v->affinity_broken = 0;
>>>>> + /* Affinity settings of one vcpu are for the complete unit. */
>>>>> + sched_set_affinity(unit->vcpu_list,
>>>>> + unit->cpu_hard_affinity_saved, NULL);
>>>>
>>>> Yet despite the comment the function gets passed a struct vcpu *,
>>>> and this doesn't look to change by the end of the series. Is there
>>>> a reason for this?
>>>
>>> Yes. sched_set_affinity() is used from outside of schedule.c (by
>>> dom0_build.c).
>>
>> How about changing the call there then, rather than having confusing
>> code here?
>
> I'm not sure that would be better.
>
> What about dropping dom0_setup_vcpu() by calling vcpu_create() instead
> and doing the pinning via a call to a new function in schedule.c after
> having created all vcpus? In fact we could even do a common function
> creating all but vcpu[0], doing the pinning and the updating the node
> affinity. Probably this would want to be part of patch 20.
Sounds reasonable at the first glance.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-24 15:00 ` Jan Beulich
@ 2019-09-24 15:09 ` Jürgen Groß
2019-09-24 15:22 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 15:09 UTC (permalink / raw)
To: Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli
On 24.09.19 17:00, Jan Beulich wrote:
> On 24.09.2019 16:41, Jürgen Groß wrote:
>> On 23.09.19 17:41, Jan Beulich wrote:
>>> On 14.09.2019 10:52, Juergen Gross wrote:
>>>> @@ -1851,7 +1852,7 @@ void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
>>>> while ( atomic_read(&next->rendezvous_out_cnt) )
>>>> cpu_relax();
>>>> }
>>>> - else if ( vprev != vnext )
>>>> + else if ( vprev != vnext && sched_granularity == 1 )
>>>> context_saved(vprev);
>>>> }
>>>
>>> Would you mind helping me with understanding why this call is
>>> needed with a granularity of 1 only?
>>
>> Otherwise it is done just a few lines up (granularity 1 will result
>> in rendezvous_out_cnt being zero).
>
> I.e. if is rendezvous_out_cnt is zero and vprev != vnext but
> sched_granularity > 1 the call isn't needed? Why? At the end of
I can add an ASSERT() here. This should never happen.
> the series vcpu_context_saved() gets called in all cases; what's
> conditional upon granularity being 1 there is the call to
> unit_context_saved().
vcpu_context_saved() at the end of the series is testing vprev != vnext.
>
>>>> + if ( is_idle_unit(unit) )
>>>> + return true;
>>>> +
>>>> + for_each_sched_unit_vcpu ( unit, v )
>>>> + if ( vcpu_runnable(v) )
>>>> + return true;
>>>
>>> Isn't the loop going to yield true anyway for idle units? If so, is
>>> there a particular reason for the special casing of idle units up
>>> front here?
>>
>> Didn't I explain that before?
>
> Quite possible; a good hint that a code comment wouldn't hurt.
Okay.
>
>> for_each_sched_unit_vcpu() for an idle
>> unit might end premature when one of the vcpus is running in another
>> unit (idle_vcpu->sched_unit != idle_unit).
>
> Oh, that (v)->sched_unit == (i) in the construct is clearly unexpected.
> Is this really still needed by the end of the series? I realize that
> _some_ check is needed, but could this perhaps be arranged in a way
> that you'd still hit all vCPU-s when using it on an idle unit, no
> matter whether they're in use as a substitute in a "real" unit?
I could do that by having another linked list in struct vcpu. This way
I can avoid it.
> As to that construct - why is the parameter named "i" rather than "u"?
> And why "e" in for_each_sched_unit()?
"i" like "item" (somehow this survived the big rename). Can change it.
"e" like "element". I think this is another relic. Can change it, too.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource
2019-09-24 12:08 ` Jan Beulich
@ 2019-09-24 15:10 ` Jürgen Groß
2019-09-24 17:07 ` Dario Faggioli
2019-09-25 6:49 ` Jürgen Groß
1 sibling, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 15:10 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Dario Faggioli, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Roger Pau Monné
On 24.09.19 14:08, Jan Beulich wrote:
> On 24.09.2019 13:41, Jürgen Groß wrote:
>> Regarding to rename "sd" to "sr": I agree this would be a sensible
>> change. OTOH I'd like to be consistent, so I'd like to defer that to
>> the planned scheduling cleanup series.
>
> Seeing another introduction of "sd" in as late as patch 37, I really
> wonder if this approach (and the resulting extra code churn) is
> indeed better than naming at least new variable instances properly
> right away.
Okay with me. What do scheduler maintainers think?
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 32/47] xen/sched: support allocating multiple vcpus into one sched unit
2019-09-24 10:13 ` Jan Beulich
@ 2019-09-24 15:13 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 15:13 UTC (permalink / raw)
To: Jan Beulich; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 24.09.19 12:13, Jan Beulich wrote:
> On 24.09.2019 12:06, Jürgen Groß wrote:
>> On 24.09.19 11:46, Jan Beulich wrote:
>>> On 14.09.2019 10:52, Juergen Gross wrote:
>>>> @@ -366,18 +380,38 @@ static void sched_free_unit(struct sched_unit *unit)
>>>> xfree(unit);
>>>> }
>>>>
>>>> +static void sched_unit_add_vcpu(struct sched_unit *unit, struct vcpu *v)
>>>> +{
>>>> + v->sched_unit = unit;
>>>> + if ( !unit->vcpu_list || unit->vcpu_list->vcpu_id > v->vcpu_id )
>>>
>>> Is the right side needed? Aren't vCPU-s created in increasing order
>>> of their IDs, and aren't we relying on this elsewhere too?
>>
>> Idle vcpus are rather special and they require the second test.
>
> How about a code comment to this effect?
Okay.
>
>>>> + {
>>>> + unit->vcpu_list = v;
>>>> + unit->unit_id = v->vcpu_id;
>>>
>>> This makes for a pretty strange set of IDs (non-successive), and
>>> explains why patch 24 uses a local "unit_idx" instead of switching
>>> from v->vcpu_id as array index to unit->unit_id. Is there a reason
>>> you don't divide by the granularity here, eliminating the division
>>> done e.g. ...
>>
>> Cpus not in a cpupool are in single-vcpu units, so in order for not
>> having completely weird unit-ids after having move cpus a lot in and
>> out of cpupools keeping the current scheme is the only one I could
>> think of.
>
> And how about extending the description to include this?
Okay.
>
>>>> + }
>>>> + unit->runstate_cnt[v->runstate.state]++;
>>>> +}
>>>> +
>>>> static struct sched_unit *sched_alloc_unit(struct vcpu *v)
>>>> {
>>>> struct sched_unit *unit, **prev_unit;
>>>> struct domain *d = v->domain;
>>>>
>>>> + for_each_sched_unit ( d, unit )
>>>> + if ( unit->vcpu_list->vcpu_id / sched_granularity ==
>>>
>>> ... here. (I also don't see why you don't use unit->unit_id here.)
>
> And is there a reason not to use unit->unit_id here then, which
> is slightly cheaper to access?
Right, will change.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 33/47] xen/sched: add a percpu resource index
2019-09-24 10:05 ` Jan Beulich
@ 2019-09-24 15:20 ` Jürgen Groß
2019-09-24 15:29 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-24 15:20 UTC (permalink / raw)
To: Jan Beulich; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 24.09.19 12:05, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> --- a/xen/common/schedule.c
>> +++ b/xen/common/schedule.c
>> @@ -71,6 +71,7 @@ static void poll_timer_fn(void *data);
>> /* This is global for now so that private implementations can reach it */
>> DEFINE_PER_CPU(struct scheduler *, scheduler);
>> DEFINE_PER_CPU_READ_MOSTLY(struct sched_resource *, sched_res);
>> +static DEFINE_PER_CPU_READ_MOSTLY(unsigned int, sched_res_idx);
>
> It's of course not very helpful that this variable (right here) doesn't
> ever get written to, and hence one can't judge where / how this is to
> be done (without going look elsewhere). But I guess that calculation
> can't be moved into this patch (accepting that it would always yield
> zero for now)?
Not easily. I can set sched_res_idx to 0 explicitly when initializing
a new cpu if you like that better.
>
>> @@ -135,6 +136,12 @@ static struct scheduler sched_idle_ops = {
>> .switch_sched = sched_idle_switch_sched,
>> };
>>
>> +static inline struct vcpu *sched_unit2vcpu_cpu(struct sched_unit *unit,
>
> const (on the parameter)?
Okay.
>
>> + unsigned int cpu)
>> +{
>> + return unit->domain->vcpu[unit->unit_id + per_cpu(sched_res_idx, cpu)];
>> +}
>> +
>> static inline struct scheduler *dom_scheduler(const struct domain *d)
>> {
>> if ( likely(d->cpupool != NULL) )
>> @@ -2008,7 +2015,7 @@ static void sched_slave(void)
>>
>> pcpu_schedule_unlock_irq(lock, cpu);
>>
>> - sched_context_switch(vprev, next->vcpu_list, now);
>> + sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu), now);
>> }
>
> By the end of the series this will be
>
> sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu),
> is_idle_unit(next) && !is_idle_unit(prev), now);
>
> clarifying (I think) that "next" can indeed be an idle unit. I'm having
> difficulty seeing how can produce the correct result in all three cases
> - all vCPU-s in the unit belong to a real domain
> - all vCPU-s in the unit belong to the idle domain
> - there's a mix of "real" and (filler) "idle" vCPU-s
> My main question is what "next" is in the last of the 3 cases above.
next points to the real domain's unit.
> Considering that scheduling happens in terms of units, I'd expect it to
> be a real domain's unit, yet then I don't see how you'd get at the
> correct (idle) vCPU when calling sched_unit2vcpu_cpu(next, cpu).
What is the problem?
sched_unit2vcpu_cpu() will first get the real domain's vcpu for that cpu
(if exisiting) and replace it by the idle vcpu of that cpu if the real
domain's vcpu is either not existing or won't be running. The main trick
is that we use idle_vcpu[cpu] (which is existing today already).
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-24 15:09 ` Jürgen Groß
@ 2019-09-24 15:22 ` Jan Beulich
2019-09-25 12:40 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 15:22 UTC (permalink / raw)
To: Jürgen Groß
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli
On 24.09.2019 17:09, Jürgen Groß wrote:
> On 24.09.19 17:00, Jan Beulich wrote:
>> On 24.09.2019 16:41, Jürgen Groß wrote:
>>> On 23.09.19 17:41, Jan Beulich wrote:
>>>> On 14.09.2019 10:52, Juergen Gross wrote:
>>>>> @@ -1851,7 +1852,7 @@ void sched_context_switched(struct vcpu *vprev, struct vcpu *vnext)
>>>>> while ( atomic_read(&next->rendezvous_out_cnt) )
>>>>> cpu_relax();
>>>>> }
>>>>> - else if ( vprev != vnext )
>>>>> + else if ( vprev != vnext && sched_granularity == 1 )
>>>>> context_saved(vprev);
>>>>> }
>>>>
>>>> Would you mind helping me with understanding why this call is
>>>> needed with a granularity of 1 only?
>>>
>>> Otherwise it is done just a few lines up (granularity 1 will result
>>> in rendezvous_out_cnt being zero).
>>
>> I.e. if is rendezvous_out_cnt is zero and vprev != vnext but
>> sched_granularity > 1 the call isn't needed? Why? At the end of
>
> I can add an ASSERT() here. This should never happen.
Ah yes, this would address my question.
>> the series vcpu_context_saved() gets called in all cases; what's
>> conditional upon granularity being 1 there is the call to
>> unit_context_saved().
>
> vcpu_context_saved() at the end of the series is testing vprev != vnext.
But that part of the conditional was not under question.
>>> for_each_sched_unit_vcpu() for an idle
>>> unit might end premature when one of the vcpus is running in another
>>> unit (idle_vcpu->sched_unit != idle_unit).
>>
>> Oh, that (v)->sched_unit == (i) in the construct is clearly unexpected.
>> Is this really still needed by the end of the series? I realize that
>> _some_ check is needed, but could this perhaps be arranged in a way
>> that you'd still hit all vCPU-s when using it on an idle unit, no
>> matter whether they're in use as a substitute in a "real" unit?
>
> I could do that by having another linked list in struct vcpu. This way
> I can avoid it.
Oh, no, not another list just for this purpose. I was rather thinking
of e.g. a comparison of IDs.
>> As to that construct - why is the parameter named "i" rather than "u"?
>> And why "e" in for_each_sched_unit()?
>
> "i" like "item" (somehow this survived the big rename). Can change it.
> "e" like "element". I think this is another relic. Can change it, too.
I'd appreciate this, as it would get this more in line with the other
similar macros.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 33/47] xen/sched: add a percpu resource index
2019-09-24 15:20 ` Jürgen Groß
@ 2019-09-24 15:29 ` Jan Beulich
0 siblings, 0 replies; 161+ messages in thread
From: Jan Beulich @ 2019-09-24 15:29 UTC (permalink / raw)
To: Jürgen Groß; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 24.09.2019 17:20, Jürgen Groß wrote:
> On 24.09.19 12:05, Jan Beulich wrote:
>> On 14.09.2019 10:52, Juergen Gross wrote:
>>> --- a/xen/common/schedule.c
>>> +++ b/xen/common/schedule.c
>>> @@ -71,6 +71,7 @@ static void poll_timer_fn(void *data);
>>> /* This is global for now so that private implementations can reach it */
>>> DEFINE_PER_CPU(struct scheduler *, scheduler);
>>> DEFINE_PER_CPU_READ_MOSTLY(struct sched_resource *, sched_res);
>>> +static DEFINE_PER_CPU_READ_MOSTLY(unsigned int, sched_res_idx);
>>
>> It's of course not very helpful that this variable (right here) doesn't
>> ever get written to, and hence one can't judge where / how this is to
>> be done (without going look elsewhere). But I guess that calculation
>> can't be moved into this patch (accepting that it would always yield
>> zero for now)?
>
> Not easily. I can set sched_res_idx to 0 explicitly when initializing
> a new cpu if you like that better.
No, not really. Then better leave it as is.
>>> @@ -2008,7 +2015,7 @@ static void sched_slave(void)
>>>
>>> pcpu_schedule_unlock_irq(lock, cpu);
>>>
>>> - sched_context_switch(vprev, next->vcpu_list, now);
>>> + sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu), now);
>>> }
>>
>> By the end of the series this will be
>>
>> sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu),
>> is_idle_unit(next) && !is_idle_unit(prev), now);
>>
>> clarifying (I think) that "next" can indeed be an idle unit. I'm having
>> difficulty seeing how can produce the correct result in all three cases
>> - all vCPU-s in the unit belong to a real domain
>> - all vCPU-s in the unit belong to the idle domain
>> - there's a mix of "real" and (filler) "idle" vCPU-s
>> My main question is what "next" is in the last of the 3 cases above.
>
> next points to the real domain's unit.
>
>> Considering that scheduling happens in terms of units, I'd expect it to
>> be a real domain's unit, yet then I don't see how you'd get at the
>> correct (idle) vCPU when calling sched_unit2vcpu_cpu(next, cpu).
>
> What is the problem?
>
> sched_unit2vcpu_cpu() will first get the real domain's vcpu for that cpu
> (if exisiting) and replace it by the idle vcpu of that cpu if the real
> domain's vcpu is either not existing or won't be running. The main trick
> is that we use idle_vcpu[cpu] (which is existing today already).
Yeah, I guess this has become more clear by looking at the next
patch. Without seeing the final shape sched_unit2vcpu_cpu() will
take (i.e. including the trick you talk about) it wasn't really
clear to me what is (supposed to be) going on here. (Makes me
wonder once again whether that function couldn't have taken its
final shape right away. But anyway.)
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource
2019-09-24 15:10 ` Jürgen Groß
@ 2019-09-24 17:07 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-24 17:07 UTC (permalink / raw)
To: Juergen Gross, Jan Beulich
Cc: sstabellini, wl, konrad.wilk, george.dunlap, tim, ian.jackson,
robert.vanvossen, julien.grall, josh.whitehead, mengxu,
andrew.cooper3, xen-devel, roger.pau
[-- Attachment #1.1: Type: text/plain, Size: 1100 bytes --]
On Tue, 2019-09-24 at 17:10 +0200, Jürgen Groß wrote:
> On 24.09.19 14:08, Jan Beulich wrote:
> > On 24.09.2019 13:41, Jürgen Groß wrote:
> > > Regarding to rename "sd" to "sr": I agree this would be a
> > > sensible
> > > change. OTOH I'd like to be consistent, so I'd like to defer that
> > > to
> > > the planned scheduling cleanup series.
> >
> > Seeing another introduction of "sd" in as late as patch 37, I
> > really
> > wonder if this approach (and the resulting extra code churn) is
> > indeed better than naming at least new variable instances properly
> > right away.
>
> Okay with me. What do scheduler maintainers think?
>
I do prefer 'sr'. As to whether this happens right now, but only for
new variables, or all at once in a followup series, either approach is
fine for me.
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource
2019-09-24 11:41 ` Jürgen Groß
2019-09-24 12:08 ` Jan Beulich
@ 2019-09-24 17:11 ` Dario Faggioli
1 sibling, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-24 17:11 UTC (permalink / raw)
To: Jürgen Groß, Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Robert VanVossen,
Julien Grall, Josh Whitehead, Meng Xu, xen-devel, Ian Jackson,
Roger Pau Monné
[-- Attachment #1.1: Type: text/plain, Size: 886 bytes --]
On Tue, 2019-09-24 at 13:41 +0200, Jürgen Groß wrote:
> On 19.09.19 17:27, Jan Beulich wrote:
> > On 14.09.2019 10:52, Juergen Gross wrote:
> > >
> > > -DECLARE_PER_CPU(struct schedule_data, schedule_data);
> > > +#define curr_on_cpu(c) (get_sched_res(c)->curr)
> >
> > By moving this a few lines down if could become an inline function
> > as it seems, if (see above) its use as an lvalue is not intended.
>
> I like that idea. Will change to inline function.
>
Yes, definitely better. With this (turning to inline func) done:
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 08/47] xen/sched: switch vcpu_schedule_lock to unit_schedule_lock
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 08/47] xen/sched: switch vcpu_schedule_lock to unit_schedule_lock Juergen Gross
@ 2019-09-24 17:18 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-24 17:18 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Julien Grall, Meng Xu,
Jan Beulich, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 929 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Rename vcpu_schedule_[un]lock[_irq]() to
> unit_schedule_[un]lock[_irq]()
> and let it take a sched_unit pointer instead of a vcpu pointer as
> parameter.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
I guess 'No functional change', or something like that, could be added
to the changelog.
This is not a strong requirement, tough, as I think it could become
quite repetitive, if it is really added to all the patches doing only
mechanical changes.
So I leave this to committers to decide if we really want it.
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 09/47] xen/sched: move some per-vcpu items to struct sched_unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 09/47] xen/sched: move some per-vcpu items to struct sched_unit Juergen Gross
2019-09-19 15:38 ` Jan Beulich
@ 2019-09-24 17:23 ` Dario Faggioli
1 sibling, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-24 17:23 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, Meng Xu, Jan Beulich
[-- Attachment #1.1: Type: text/plain, Size: 1035 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Affinities are scheduler specific attributes, they should be per
> scheduling unit. So move all affinity related fields in struct vcpu
> to struct sched_unit. While at it switch affinity related functions
> in
> sched-if.h to use a pointer to sched_unit instead to vcpu as
> parameter.
>
> The affinity_broken flag must be kept per vcpu as it is related to
> guest actions on specific vcpus. When support of multiple vcpus per
> sched_unit is being added, a unit is regarded as being subject to
> "broken affinity" when any of its vcpus has the affinity_broken flag
> set.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 11/47] xen/sched: rename scheduler related perf counters
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 11/47] xen/sched: rename scheduler related perf counters Juergen Gross
@ 2019-09-24 17:25 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-24 17:25 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Julien Grall, Meng Xu,
Jan Beulich, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 535 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Rename the scheduler related perf counters from vcpu* to unit* where
> appropriate.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support
2019-09-24 11:15 ` Sergey Dyasli
2019-09-24 11:17 ` Jürgen Groß
@ 2019-09-24 17:29 ` Dario Faggioli
2019-09-24 17:42 ` Igor Druzhinin
1 sibling, 1 reply; 161+ messages in thread
From: Dario Faggioli @ 2019-09-24 17:29 UTC (permalink / raw)
To: Sergey Dyasli, Juergen Gross, xen-devel
Cc: Igor Druzhinin, Stefano Stabellini, Wei Liu,
Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Tim Deegan,
Robert VanVossen, Julien Grall, Josh Whitehead, Meng Xu,
Jan Beulich, Volodymyr Babchuk, Ian Jackson, Roger Pau Monné
[-- Attachment #1.1: Type: text/plain, Size: 851 bytes --]
On Tue, 2019-09-24 at 12:15 +0100, Sergey Dyasli wrote:
> Hi Juergen,
>
> After an extensive testing of your jgross1/sched-v3 branch in XenRT,
> I'm happy to say that we've found no functional regressions so far
> when running in the default (thread/cpu) mode.
>
> Hopefully this gives some level of confidence to this series and the
> plan about including it into 4.13 [1]
>
Thanks a lot for doing this, and for letting us know.
Can I ask whether the tests were done using Credit2 (i.e., upstream
default) or Credit1, as scheduler?
Thanks again and Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support
2019-09-24 17:29 ` Dario Faggioli
@ 2019-09-24 17:42 ` Igor Druzhinin
0 siblings, 0 replies; 161+ messages in thread
From: Igor Druzhinin @ 2019-09-24 17:42 UTC (permalink / raw)
To: Dario Faggioli, Sergey Dyasli, Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Robert VanVossen,
Julien Grall, Josh Whitehead, Meng Xu, Jan Beulich,
Volodymyr Babchuk, Ian Jackson, Roger Pau Monné
On 24/09/2019 18:29, Dario Faggioli wrote:
> On Tue, 2019-09-24 at 12:15 +0100, Sergey Dyasli wrote:
>> Hi Juergen,
>>
>> After an extensive testing of your jgross1/sched-v3 branch in XenRT,
>> I'm happy to say that we've found no functional regressions so far
>> when running in the default (thread/cpu) mode.
>>
>> Hopefully this gives some level of confidence to this series and the
>> plan about including it into 4.13 [1]
>>
> Thanks a lot for doing this, and for letting us know.
Additionally, we've got performance test results today and they showed
no noticeable regressions in thread mode against 4.13 without
core-scheduling patches.
> Can I ask whether the tests were done using Credit2 (i.e., upstream
> default) or Credit1, as scheduler?
>
That was Credit1 that we use in the product.
Igor
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 23/47] xen/sched: switch sched_move_irqs() to take sched_unit as parameter
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 23/47] xen/sched: switch sched_move_irqs() to take sched_unit as parameter Juergen Gross
2019-09-20 14:34 ` Jan Beulich
@ 2019-09-24 20:43 ` Dario Faggioli
1 sibling, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-24 20:43 UTC (permalink / raw)
To: Juergen Gross, xen-devel; +Cc: George Dunlap
[-- Attachment #1.1: Type: text/plain, Size: 687 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> sched_move_irqs() should work on a sched_unit as that is the unit
> moved between cpus.
>
> Rename the current function to vcpu_move_irqs() as it is still needed
> in schedule().
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
(Stands with parameter constified as suggested.)
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 26/47] xen/sched: Change vcpu_migrate_*() to operate on schedule unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 26/47] xen/sched: Change vcpu_migrate_*() to operate on schedule unit Juergen Gross
@ 2019-09-24 22:33 ` Dario Faggioli
2019-09-25 12:04 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Dario Faggioli @ 2019-09-24 22:33 UTC (permalink / raw)
To: Juergen Gross, xen-devel; +Cc: George Dunlap
[-- Attachment #1.1: Type: text/plain, Size: 1923 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Now that vcpu_migrate_start() and vcpu_migrate_finish() are used only
> to ensure a vcpu is running on a suitable processor
>
Is this sentence like this (I mean with that "Now" at the beginning)
because it was --in previous versions of the series-- right after the
patch that changed vcpu_force_reschedule()?
If yes, then that is not the case any longer, so we may want to re-
phrase.
> they can be
> switched to operate on schedule units instead of vcpus.
>
> While doing that rename them accordingly and make the _start()
> variant
> static.
>
What does this mean/refer to?
Wasn't vcpu_migrate_start() static already?
> As it is needed anyway call vcpu_sync_execstate() for each
> vcpu of the unit when changing processors.
>
Again, what do you mean with "As it is needed anyway"?
> diff --git a/xen/common/schedule.c b/xen/common/schedule.c
> index 0bd9f0d278..70271cdea2 100644
> --- a/xen/common/schedule.c
> +++ b/xen/common/schedule.c
>
> /*
> * Initiating migration
> *
> - * In order to migrate, we need the vcpu in question to have stopped
> + * In order to migrate, we need the unit in question to have stopped
> * running and had sched_sleep() called (to take it off any
>
Might be me (not a native speaker), but this reads weird. "and have
called sched_sleep()" or "and sched_sleep() to have been called" would
sound better.
It's, of course, not your fault, but I guess we can consider adjusting
it, since we are touching the line above it.
Or maybe you also want to queue it up for the cleanup series?
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource
2019-09-24 12:08 ` Jan Beulich
2019-09-24 15:10 ` Jürgen Groß
@ 2019-09-25 6:49 ` Jürgen Groß
1 sibling, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 6:49 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Robert VanVossen,
Dario Faggioli, Julien Grall, Josh Whitehead, Meng Xu, xen-devel,
Roger Pau Monné
On 24.09.19 14:08, Jan Beulich wrote:
> On 24.09.2019 13:41, Jürgen Groß wrote:
>> Regarding to rename "sd" to "sr": I agree this would be a sensible
>> change. OTOH I'd like to be consistent, so I'd like to defer that to
>> the planned scheduling cleanup series.
>
> Seeing another introduction of "sd" in as late as patch 37, I really
> wonder if this approach (and the resulting extra code churn) is
> indeed better than naming at least new variable instances properly
> right away.
And after renaming new instances of "sd" to "sr" there were so few "sd"s
left that I renamed them right away.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 26/47] xen/sched: Change vcpu_migrate_*() to operate on schedule unit
2019-09-24 22:33 ` Dario Faggioli
@ 2019-09-25 12:04 ` Jürgen Groß
2019-09-25 16:37 ` Dario Faggioli
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 12:04 UTC (permalink / raw)
To: Dario Faggioli, xen-devel; +Cc: George Dunlap
On 25.09.19 00:33, Dario Faggioli wrote:
> On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
>> Now that vcpu_migrate_start() and vcpu_migrate_finish() are used only
>> to ensure a vcpu is running on a suitable processor
>>
> Is this sentence like this (I mean with that "Now" at the beginning)
> because it was --in previous versions of the series-- right after the
> patch that changed vcpu_force_reschedule()?
>
> If yes, then that is not the case any longer, so we may want to re-
> phrase.
Indeed.
>
>> they can be
>> switched to operate on schedule units instead of vcpus.
>>
>> While doing that rename them accordingly and make the _start()
>> variant
>> static.
>>
> What does this mean/refer to?
>
> Wasn't vcpu_migrate_start() static already?
Wei cheated. He modified it with commit 9f8d606b4384408. :-)
>
>> As it is needed anyway call vcpu_sync_execstate() for each
>> vcpu of the unit when changing processors.
>>
> Again, what do you mean with "As it is needed anyway"?
When moving from one cpu to another one the state must be saved in
struct vcpu (in contrast to being held partially in registers or on the
stack in case only the idle vcpu was scheduled afterwards on the old
cpu). This is done by vcpu_sync_execstate(). Without the explicit call
it would be done either when the vcpu is being scheduled on the new cpu
or if another non-idle vcpu is becoming active on the old cpu.
>
>> diff --git a/xen/common/schedule.c b/xen/common/schedule.c
>> index 0bd9f0d278..70271cdea2 100644
>> --- a/xen/common/schedule.c
>> +++ b/xen/common/schedule.c
>>
>> /*
>> * Initiating migration
>> *
>> - * In order to migrate, we need the vcpu in question to have stopped
>> + * In order to migrate, we need the unit in question to have stopped
>> * running and had sched_sleep() called (to take it off any
>>
> Might be me (not a native speaker), but this reads weird. "and have
> called sched_sleep()" or "and sched_sleep() to have been called" would
> sound better.
>
> It's, of course, not your fault, but I guess we can consider adjusting
> it, since we are touching the line above it.
>
> Or maybe you also want to queue it up for the cleanup series?
No, I'll change it.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-24 15:22 ` Jan Beulich
@ 2019-09-25 12:40 ` Jürgen Groß
2019-09-25 13:07 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 12:40 UTC (permalink / raw)
To: Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli
On 24.09.19 17:22, Jan Beulich wrote:
> On 24.09.2019 17:09, Jürgen Groß wrote:
>> On 24.09.19 17:00, Jan Beulich wrote:
>>> On 24.09.2019 16:41, Jürgen Groß wrote:
>>>> for_each_sched_unit_vcpu() for an idle
>>>> unit might end premature when one of the vcpus is running in another
>>>> unit (idle_vcpu->sched_unit != idle_unit).
>>>
>>> Oh, that (v)->sched_unit == (i) in the construct is clearly unexpected.
>>> Is this really still needed by the end of the series? I realize that
>>> _some_ check is needed, but could this perhaps be arranged in a way
>>> that you'd still hit all vCPU-s when using it on an idle unit, no
>>> matter whether they're in use as a substitute in a "real" unit?
>>
>> I could do that by having another linked list in struct vcpu. This way
>> I can avoid it.
>
> Oh, no, not another list just for this purpose. I was rather thinking
> of e.g. a comparison of IDs.
That would result either in something like:
(v)->vcpu_id < (u)->unit_id + (u)->res->cpupool->granularity
requiring to make struct sched_resource public as keyhandler.c needs
for_each_sched_unit_vcpu() plus being quite expensive, or:
!(u)->next_in_list || (v)->vcpu_id < (u)->next_in_list->unit_id
which seems to be more expensive as the current variant, too.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 14/47] xen/sched: make null scheduler vcpu agnostic.
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 14/47] xen/sched: make null scheduler vcpu agnostic Juergen Gross
@ 2019-09-25 12:51 ` Dario Faggioli
2019-09-25 12:59 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 12:51 UTC (permalink / raw)
To: Juergen Gross, xen-devel; +Cc: George Dunlap
[-- Attachment #1.1: Type: text/plain, Size: 2083 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Switch null scheduler completely from vcpu to sched_unit usage.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
With, if possible, all the occurrences of 'item' in comments actually
replaced with 'unit'.
Like, for instance, these...
> diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
> index 63ee1f5439..c3666c9f56 100644
> --- a/xen/common/sched_null.c
> +++ b/xen/common/sched_null.c
> @@ -18,10 +18,10 @@
>
> /*
> * The 'null' scheduler always choose to run, on each pCPU, either
> nothing
> - * (i.e., the pCPU stays idle) or always the same vCPU.
> + * (i.e., the pCPU stays idle) or always the same Item.
> *
> * It is aimed at supporting static scenarios, where there always
> are
> - * less vCPUs than pCPUs (and the vCPUs don't need to move among
> pCPUs
> + * less Items than pCPUs (and the Items don't need to move among
> pCPUs
> * for any reason) with the least possible overhead.
> *
> * Typical usecase are embedded applications, but also HPC,
> especially
>
...
> @@ -77,25 +77,25 @@
> struct null_private {
> spinlock_t lock; /* scheduler lock; nests inside
> cpupool_lock */
> struct list_head ndom; /* Domains of this
> scheduler */
> - struct list_head waitq; /* vCPUs not assigned to any
> pCPU */
> + struct list_head waitq; /* Items not assigned to any
> pCPU */
> spinlock_t waitq_lock; /* serializes waitq; nests inside runq
> locks */
> - cpumask_t cpus_free; /* CPUs without a vCPU associated to
> them */
> + cpumask_t cpus_free; /* CPUs without a Item associated to
> them */
> };
>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 34/47] xen/sched: add fall back to idle vcpu when scheduling unit
2019-09-24 10:53 ` Jan Beulich
@ 2019-09-25 12:58 ` Jürgen Groß
2019-09-25 13:11 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 12:58 UTC (permalink / raw)
To: Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli, Volodymyr Babchuk,
Roger Pau Monné
On 24.09.19 12:53, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> When scheduling an unit with multiple vcpus there is no guarantee all
>> vcpus are available (e.g. above maxvcpus or vcpu offline). Fall back to
>> idle vcpu of the current cpu in that case. This requires to store the
>> correct schedule_unit pointer in the idle vcpu as long as it used as
>> fallback vcpu.
>>
>> In order to modify the runstates of the correct vcpus when switching
>> schedule units merge sched_unit_runstate_change() into
>> sched_switch_units() and loop over the affected physical cpus instead
>> of the unit's vcpus. This in turn requires an access function to the
>> current variable of other cpus.
>>
>> Today context_saved() is called in case previous and next vcpus differ
>> when doing a context switch. With an idle vcpu being capable to be a
>> substitute for an offline vcpu this is problematic when switching to
>> an idle scheduling unit. An idle previous vcpu leaves us in doubt which
>> schedule unit was active previously, so save the previous unit pointer
>> in the per-schedule resource area. If it is NULL the unit has not
>> changed and we don't have to set the previous unit to be not running.
>>
>> When running an idle vcpu in a non-idle scheduling unit use a specific
>> guest idle loop not performing any tasklets and livepatching in order
>> to avoid populating the cpu caches with memory used by other domains
>> (as far as possible). Softirqs are considered to be save.
>
> Aiui "tasklets" here means only ones run in (idle) vCPU context, whereas
> "softirqs" includes tasklets run in softirq context. I think it would
> help if the description made this distinction. With this I then wonder
> whether the cache related argumentation above still holds: VT-d's IOMMU
> fault handling tasklet runs in softirq context, for example, and
> hvm_assert_evtchn_irq(), being handed a struct vcpu *, does too. Of
> course this could be considered covered by "(as far as possible)" ...
I'll write "... not performing any non-softirq tasklets ...".
>
>> @@ -172,6 +191,10 @@ void startup_cpu_idle_loop(void)
>>
>> static void noreturn continue_idle_domain(struct vcpu *v)
>> {
>> + /* Idle vcpus might be attached to non-idle units! */
>> + if ( !is_idle_domain(v->sched_unit->domain) )
>> + reset_stack_and_jump_nolp(guest_idle_loop);
>
> The construct and comment make me wonder - did you audit all uses
> of is_idle_{domain,vcpu}() for being in line with this new usage
> mode?
Yes.
>
>> @@ -1767,33 +1774,66 @@ static void sched_switch_units(struct sched_resource *sd,
>> struct sched_unit *next, struct sched_unit *prev,
>> s_time_t now)
>> {
>> - sd->curr = next;
>> -
>> - TRACE_3D(TRC_SCHED_SWITCH_INFPREV, prev->domain->domain_id, prev->unit_id,
>> - now - prev->state_entry_time);
>> - TRACE_4D(TRC_SCHED_SWITCH_INFNEXT, next->domain->domain_id, next->unit_id,
>> - (next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
>> - (now - next->state_entry_time) : 0, prev->next_time);
>> + int cpu;
>
> unsigned int?
Okay.
>
>> ASSERT(unit_running(prev));
>>
>> - TRACE_4D(TRC_SCHED_SWITCH, prev->domain->domain_id, prev->unit_id,
>> - next->domain->domain_id, next->unit_id);
>> + if ( prev != next )
>> + {
>> + sd->curr = next;
>> + sd->prev = prev;
>>
>> - sched_unit_runstate_change(prev, false, now);
>> + TRACE_3D(TRC_SCHED_SWITCH_INFPREV, prev->domain->domain_id,
>> + prev->unit_id, now - prev->state_entry_time);
>> + TRACE_4D(TRC_SCHED_SWITCH_INFNEXT, next->domain->domain_id,
>> + next->unit_id,
>> + (next->vcpu_list->runstate.state == RUNSTATE_runnable) ?
>> + (now - next->state_entry_time) : 0, prev->next_time);
>> + TRACE_4D(TRC_SCHED_SWITCH, prev->domain->domain_id, prev->unit_id,
>> + next->domain->domain_id, next->unit_id);
>>
>> - ASSERT(!unit_running(next));
>> - sched_unit_runstate_change(next, true, now);
>> + ASSERT(!unit_running(next));
>>
>> - /*
>> - * NB. Don't add any trace records from here until the actual context
>> - * switch, else lost_records resume will not work properly.
>> - */
>> + /*
>> + * NB. Don't add any trace records from here until the actual context
>> + * switch, else lost_records resume will not work properly.
>> + */
>> +
>> + ASSERT(!next->is_running);
>> + next->is_running = 1;
>> + next->state_entry_time = now;
>> +
>> + if ( is_idle_unit(prev) )
>> + {
>> + prev->runstate_cnt[RUNSTATE_running] = 0;
>> + prev->runstate_cnt[RUNSTATE_runnable] = sched_granularity;
>> + }
>> + if ( is_idle_unit(next) )
>> + {
>> + next->runstate_cnt[RUNSTATE_running] = sched_granularity;
>> + next->runstate_cnt[RUNSTATE_runnable] = 0;
>> + }
>
> Is this correct when some of the vCPU-s a substitute idle ones?
Yes, as this affects idle units only. An idle vcpu running as a
substitute will _not_ result in the related idle unit runstate_cnt
to be updated.
>
>> @@ -1849,29 +1889,39 @@ static struct sched_unit *do_schedule(struct sched_unit *prev, s_time_t now,
>> if ( prev->next_time >= 0 ) /* -ve means no limit */
>> set_timer(&sd->s_timer, now + prev->next_time);
>>
>> - if ( likely(prev != next) )
>> - sched_switch_units(sd, next, prev, now);
>> + sched_switch_units(sd, next, prev, now);
>>
>> return next;
>> }
>>
>> -static void context_saved(struct vcpu *prev)
>> +static void vcpu_context_saved(struct vcpu *vprev, struct vcpu *vnext)
>> {
>> - struct sched_unit *unit = prev->sched_unit;
>> -
>> /* Clear running flag /after/ writing context to memory. */
>> smp_wmb();
>>
>> - prev->is_running = 0;
>> + if ( vprev != vnext )
>> + vprev->is_running = 0;
>> +}
>
> With this "vnext" could be const qualified as it seems. And "false"
> instead of "0" perhaps, as you touch this anyway?
Okay.
>
>> @@ -2015,7 +2079,8 @@ static void sched_slave(void)
>>
>> pcpu_schedule_unlock_irq(lock, cpu);
>>
>> - sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu), now);
>> + sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu),
>> + is_idle_unit(next) && !is_idle_unit(prev), now);
>> }
>>
>> /*
>> @@ -2075,7 +2140,8 @@ static void schedule(void)
>> pcpu_schedule_unlock_irq(lock, cpu);
>>
>> vnext = sched_unit2vcpu_cpu(next, cpu);
>> - sched_context_switch(vprev, vnext, now);
>> + sched_context_switch(vprev, vnext,
>> + !is_idle_unit(prev) && is_idle_unit(next), now);
>> }
>
> As a minor remark, I think between such constructs it would be good
> if there was no difference, unless there's a reason to have one. Yet
> if there was a reason, it surely would want to be spelled out.
I guess you mean changing the parameters of sched_context_switch()? I
can do that.
>
>> @@ -124,16 +129,22 @@ unsigned long get_stack_dump_bottom (unsigned long sp);
>> # define CHECK_FOR_LIVEPATCH_WORK ""
>> #endif
>>
>> -#define reset_stack_and_jump(__fn) \
>> +#define switch_stack_and_jump(fn, instr) \
>
> Is there any dependency on "instr" to just be a single instruction?
> I'm inclined to ask for it to be named "extra" or some such.
Fine with me.
>
>> --- a/xen/include/asm-x86/smp.h
>> +++ b/xen/include/asm-x86/smp.h
>> @@ -76,6 +76,9 @@ void set_nr_sockets(void);
>> /* Representing HT and core siblings in each socket. */
>> extern cpumask_t **socket_cpumask;
>>
>> +#define get_cpu_current(cpu) \
>> + (get_cpu_info_from_stack((unsigned long)stack_base[cpu])->current_vcpu)
>
> I don't think this can go without a comment clarifying under what
> (pretty narrow I think) conditions this is legitimate to use.
Okay. I'll add a comment like: "to be used only while no context switch
can occur on the cpu".
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 14/47] xen/sched: make null scheduler vcpu agnostic.
2019-09-25 12:51 ` Dario Faggioli
@ 2019-09-25 12:59 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 12:59 UTC (permalink / raw)
To: Dario Faggioli, xen-devel; +Cc: George Dunlap
On 25.09.19 14:51, Dario Faggioli wrote:
> On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
>> Switch null scheduler completely from vcpu to sched_unit usage.
>>
>> Signed-off-by: Juergen Gross <jgross@suse.com>
>>
> Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
>
> With, if possible, all the occurrences of 'item' in comments actually
> replaced with 'unit'.
>
> Like, for instance, these...
Oh, thanks for noticing those!
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 35/47] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware
2019-09-24 11:55 ` Jan Beulich
@ 2019-09-25 13:07 ` Jürgen Groß
2019-09-27 4:42 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 13:07 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 24.09.19 13:55, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> --- a/xen/common/schedule.c
>> +++ b/xen/common/schedule.c
>> @@ -724,8 +724,10 @@ void sched_destroy_domain(struct domain *d)
>> }
>> }
>>
>> -void vcpu_sleep_nosync_locked(struct vcpu *v)
>> +static void vcpu_sleep_nosync_locked(struct vcpu *v)
>> {
>> + struct sched_unit *unit = v->sched_unit;
>> +
>> ASSERT(spin_is_locked(get_sched_res(v->processor)->schedule_lock));
>>
>> if ( likely(!vcpu_runnable(v)) )
>> @@ -733,7 +735,14 @@ void vcpu_sleep_nosync_locked(struct vcpu *v)
>> if ( v->runstate.state == RUNSTATE_runnable )
>> vcpu_runstate_change(v, RUNSTATE_offline, NOW());
>>
>> - sched_sleep(vcpu_scheduler(v), v->sched_unit);
>> + if ( likely(!unit_runnable(unit)) )
>> + sched_sleep(vcpu_scheduler(v), unit);
>
> unit_scheduler(unit) (also elsewhere)?
Yes.
>
>> @@ -765,16 +774,22 @@ void vcpu_wake(struct vcpu *v)
>> {
>> unsigned long flags;
>> spinlock_t *lock;
>> + struct sched_unit *unit = v->sched_unit;
>>
>> TRACE_2D(TRC_SCHED_WAKE, v->domain->domain_id, v->vcpu_id);
>>
>> - lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
>> + lock = unit_schedule_lock_irqsave(unit, &flags);
>>
>> if ( likely(vcpu_runnable(v)) )
>> {
>> if ( v->runstate.state >= RUNSTATE_blocked )
>> vcpu_runstate_change(v, RUNSTATE_runnable, NOW());
>> - sched_wake(vcpu_scheduler(v), v->sched_unit);
>> + sched_wake(vcpu_scheduler(v), unit);
>
> Is this correct / necessary when the unit is not asleep as a whole?
> After all the corresponding sched_sleep() further up is called
> conditionally only.
Oh, indeed. Will change that.
>
>> @@ -1998,6 +2013,62 @@ static void sched_context_switch(struct vcpu *vprev, struct vcpu *vnext,
>> context_switch(vprev, vnext);
>> }
>>
>> +/*
>> + * Force a context switch of a single vcpu of an unit.
>> + * Might be called either if a vcpu of an already running unit is woken up
>> + * or if a vcpu of a running unit is put asleep with other vcpus of the same
>> + * unit still running.
>> + */
>> +static struct vcpu *sched_force_context_switch(struct vcpu *vprev,
>> + struct vcpu *v,
>> + int cpu, s_time_t now)
>
> unsigned int cpu? (Aiui it's suppose to equal smp_processor_id()
> anyway.)
Yes and yes.
>
>> +{
>> + v->force_context_switch = false;
>> +
>> + if ( vcpu_runnable(v) == v->is_running )
>> + return NULL;
>
> This and other NULL returns suggest that the comment ahead of the
> function might better state what the return value here is / means.
Okay.
>
>> + if ( vcpu_runnable(v) )
>> + {
>> + if ( is_idle_vcpu(vprev) )
>> + {
>> + vcpu_runstate_change(vprev, RUNSTATE_runnable, now);
>> + vprev->sched_unit = get_sched_res(cpu)->sched_unit_idle;
>> + }
>> + vcpu_runstate_change(v, RUNSTATE_running, now);
>> + }
>> + else
>> + {
>> + /* Make sure not to switch last vcpu of an unit away. */
>> + if ( unit_running(v->sched_unit) == 1 )
>> + return NULL;
>> +
>> + v->new_state = vcpu_runstate_blocked(v);
>> + vcpu_runstate_change(v, v->new_state, now);
>> + v = sched_unit2vcpu_cpu(vprev->sched_unit, cpu);
>> + if ( v != vprev )
>> + {
>> + if ( is_idle_vcpu(vprev) )
>> + {
>> + vcpu_runstate_change(vprev, RUNSTATE_runnable, now);
>> + vprev->sched_unit = get_sched_res(cpu)->sched_unit_idle;
>> + }
>> + else
>> + {
>> + v->sched_unit = vprev->sched_unit;
>> + vcpu_runstate_change(v, RUNSTATE_running, now);
>> + }
>> + }
>> + }
>> +
>> + v->is_running = 1;
>
> Besides this wanting to use "true", how come this is unconditional
> despite the function here being used for both waking and putting to
> sleep of a vCPU?
At that time v is the vcpu which will be running next, so either the
just woken up one, or the idle vcpu. I can add a comment.
>
>> @@ -2067,9 +2160,29 @@ static void sched_slave(void)
>>
>> now = NOW();
>>
>> + v = unit2vcpu_cpu(prev, cpu);
>> + if ( v && v->force_context_switch )
>> + {
>> + v = sched_force_context_switch(vprev, v, cpu, now);
>> +
>> + if ( v )
>> + {
>> + pcpu_schedule_unlock_irq(lock, cpu);
>
> I can't figure what it is that guarantees that this unlock isn't
> going to be followed ...
>
>> + sched_context_switch(vprev, v, false, now);
>> + }
>> +
>> + do_softirq = true;
>> + }
>> +
>> if ( !prev->rendezvous_in_cnt )
>> {
>> pcpu_schedule_unlock_irq(lock, cpu);
>
> ... by another unlock here. Or wait - is sched_context_switch()
> (and perhaps other functions involved there) lacking a "noreturn"
> annotation?
Indeed it is. Like context_switch() today. :-)
I'll annotate the functions.
>
>> --- a/xen/include/xen/sched-if.h
>> +++ b/xen/include/xen/sched-if.h
>> @@ -100,6 +100,11 @@ static inline bool unit_runnable(const struct sched_unit *unit)
>> return false;
>> }
>>
>> +static inline int vcpu_runstate_blocked(struct vcpu *v)
>
> const?
Yes.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-25 12:40 ` Jürgen Groß
@ 2019-09-25 13:07 ` Jan Beulich
2019-09-26 13:53 ` Dario Faggioli
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-25 13:07 UTC (permalink / raw)
To: Jürgen Groß, George Dunlap, Dario Faggioli
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
Andrew Cooper, Ian Jackson, Tim Deegan, Julien Grall, xen-devel
On 25.09.2019 14:40, Jürgen Groß wrote:
> On 24.09.19 17:22, Jan Beulich wrote:
>> On 24.09.2019 17:09, Jürgen Groß wrote:
>>> On 24.09.19 17:00, Jan Beulich wrote:
>>>> On 24.09.2019 16:41, Jürgen Groß wrote:
>>>>> for_each_sched_unit_vcpu() for an idle
>>>>> unit might end premature when one of the vcpus is running in another
>>>>> unit (idle_vcpu->sched_unit != idle_unit).
>>>>
>>>> Oh, that (v)->sched_unit == (i) in the construct is clearly unexpected.
>>>> Is this really still needed by the end of the series? I realize that
>>>> _some_ check is needed, but could this perhaps be arranged in a way
>>>> that you'd still hit all vCPU-s when using it on an idle unit, no
>>>> matter whether they're in use as a substitute in a "real" unit?
>>>
>>> I could do that by having another linked list in struct vcpu. This way
>>> I can avoid it.
>>
>> Oh, no, not another list just for this purpose. I was rather thinking
>> of e.g. a comparison of IDs.
>
> That would result either in something like:
>
> (v)->vcpu_id < (u)->unit_id + (u)->res->cpupool->granularity
>
> requiring to make struct sched_resource public as keyhandler.c needs
> for_each_sched_unit_vcpu() plus being quite expensive,
I agree this is not a good option.
> or:
>
> !(u)->next_in_list || (v)->vcpu_id < (u)->next_in_list->unit_id
>
> which seems to be more expensive as the current variant, too.
It's not this much more expensive, and it eliminates unexpected
(as I would call it) behavior, so I think I'd go this route. Let's
see if others, in particular Dario or George, have an opinion
either way.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 36/47] xen/sched: carve out freeing sched_unit memory into dedicated function
2019-09-24 12:04 ` Jan Beulich
@ 2019-09-25 13:09 ` Jürgen Groß
2019-09-25 13:16 ` Jan Beulich
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 13:09 UTC (permalink / raw)
To: Jan Beulich; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 24.09.19 14:04, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> --- a/xen/common/schedule.c
>> +++ b/xen/common/schedule.c
>> @@ -351,26 +351,10 @@ static void sched_spin_unlock_double(spinlock_t *lock1, spinlock_t *lock2,
>> spin_unlock_irqrestore(lock1, flags);
>> }
>>
>> -static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
>> +static void sched_free_unit_mem(struct sched_unit *unit)
>> {
>> struct sched_unit *prev_unit;
>> struct domain *d = unit->domain;
>> - struct vcpu *vunit;
>> - unsigned int cnt = 0;
>> -
>> - /* Don't count to be released vcpu, might be not in vcpu list yet. */
>> - for_each_sched_unit_vcpu ( unit, vunit )
>> - if ( vunit != v )
>> - cnt++;
>> -
>> - v->sched_unit = NULL;
>> - unit->runstate_cnt[v->runstate.state]--;
>> -
>> - if ( cnt )
>> - return;
>> -
>> - if ( unit->vcpu_list == v )
>> - unit->vcpu_list = v->next_in_list;
>>
>> if ( d->sched_unit_list == unit )
>> d->sched_unit_list = unit->next_in_list;
>> @@ -393,6 +377,26 @@ static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
>> xfree(unit);
>> }
>>
>> +static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
>> +{
>> + struct vcpu *vunit;
>> + unsigned int cnt = 0;
>> +
>> + /* Don't count to be released vcpu, might be not in vcpu list yet. */
>> + for_each_sched_unit_vcpu ( unit, vunit )
>> + if ( vunit != v )
>> + cnt++;
>> +
>> + v->sched_unit = NULL;
>> + unit->runstate_cnt[v->runstate.state]--;
>> +
>> + if ( unit->vcpu_list == v )
>> + unit->vcpu_list = v->next_in_list;
>> +
>> + if ( !cnt )
>> + sched_free_unit_mem(unit);
>> +}
>
> The entire sched_free_unit() is new code (starting from patch 3) - why
> don't you arrange for the split right away, instead of moving code
> around here?
I wanted to introduce new subfunctions only when they are really needed.
I can merge this patch into patch 3 if you like that better.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 34/47] xen/sched: add fall back to idle vcpu when scheduling unit
2019-09-25 12:58 ` Jürgen Groß
@ 2019-09-25 13:11 ` Jan Beulich
2019-09-25 13:15 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-25 13:11 UTC (permalink / raw)
To: Jürgen Groß
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli, Volodymyr Babchuk,
Roger Pau Monné
On 25.09.2019 14:58, Jürgen Groß wrote:
> On 24.09.19 12:53, Jan Beulich wrote:
>> On 14.09.2019 10:52, Juergen Gross wrote:
>>> @@ -2015,7 +2079,8 @@ static void sched_slave(void)
>>>
>>> pcpu_schedule_unlock_irq(lock, cpu);
>>>
>>> - sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu), now);
>>> + sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu),
>>> + is_idle_unit(next) && !is_idle_unit(prev), now);
>>> }
>>>
>>> /*
>>> @@ -2075,7 +2140,8 @@ static void schedule(void)
>>> pcpu_schedule_unlock_irq(lock, cpu);
>>>
>>> vnext = sched_unit2vcpu_cpu(next, cpu);
>>> - sched_context_switch(vprev, vnext, now);
>>> + sched_context_switch(vprev, vnext,
>>> + !is_idle_unit(prev) && is_idle_unit(next), now);
>>> }
>>
>> As a minor remark, I think between such constructs it would be good
>> if there was no difference, unless there's a reason to have one. Yet
>> if there was a reason, it surely would want to be spelled out.
>
> I guess you mean changing the parameters of sched_context_switch()? I
> can do that.
Well, yes, the two sides of the && in one of them.
>>> --- a/xen/include/asm-x86/smp.h
>>> +++ b/xen/include/asm-x86/smp.h
>>> @@ -76,6 +76,9 @@ void set_nr_sockets(void);
>>> /* Representing HT and core siblings in each socket. */
>>> extern cpumask_t **socket_cpumask;
>>>
>>> +#define get_cpu_current(cpu) \
>>> + (get_cpu_info_from_stack((unsigned long)stack_base[cpu])->current_vcpu)
>>
>> I don't think this can go without a comment clarifying under what
>> (pretty narrow I think) conditions this is legitimate to use.
>
> Okay. I'll add a comment like: "to be used only while no context switch
> can occur on the cpu".
To be crystal clear, I'd append ", i.e. by certain scheduling code only".
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 37/47] xen/sched: move per-cpu variable scheduler to struct sched_resource
2019-09-24 12:16 ` Jan Beulich
@ 2019-09-25 13:13 ` Jürgen Groß
2019-09-26 9:06 ` Dario Faggioli
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 13:13 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 24.09.19 14:16, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> --- a/xen/common/sched_credit.c
>> +++ b/xen/common/sched_credit.c
>> @@ -352,9 +352,10 @@ DEFINE_PER_CPU(unsigned int, last_tickle_cpu);
>> static inline void __runq_tickle(struct csched_unit *new)
>> {
>> unsigned int cpu = sched_unit_cpu(new->unit);
>> + struct sched_resource *sd = get_sched_res(cpu);
>> struct sched_unit *unit = new->unit;
>> struct csched_unit * const cur = CSCHED_UNIT(curr_on_cpu(cpu));
>> - struct csched_private *prv = CSCHED_PRIV(per_cpu(scheduler, cpu));
>> + struct csched_private *prv = CSCHED_PRIV(sd->scheduler);
>
> Is the single use "sd" (and, as mentioned elsewhere, mis-named)
> really worth it? (Applicable further down as well.)
>
>> @@ -931,7 +932,8 @@ csched_unit_acct(struct csched_private *prv, unsigned int cpu)
>> {
>> struct sched_unit *currunit = current->sched_unit;
>> struct csched_unit * const svc = CSCHED_UNIT(currunit);
>> - const struct scheduler *ops = per_cpu(scheduler, cpu);
>> + struct sched_resource *sd = get_sched_res(cpu);
>> + const struct scheduler *ops = sd->scheduler;
>>
>> ASSERT( sched_unit_cpu(currunit) == cpu );
>> ASSERT( svc->sdom != NULL );
>> @@ -987,8 +989,7 @@ csched_unit_acct(struct csched_private *prv, unsigned int cpu)
>> * idlers. But, if we are here, it means there is someone running
>> * on it, and hence the bit must be zero already.
>> */
>> - ASSERT(!cpumask_test_cpu(cpu,
>> - CSCHED_PRIV(per_cpu(scheduler, cpu))->idlers));
>> + ASSERT(!cpumask_test_cpu(cpu, CSCHED_PRIV(sd->scheduler)->idlers));
>
> While at the first glance "sd" is used twice here, this 2nd use is
> actually unnecessary - "cpu" hasn't changed from the beginning of
> the function afaics, and hence "ops" could be used here.
"sd" is now "sr" everywhere.
And yes, using ops here seems okay.
>
> Preferably with the suggested adjustments (but final judgement is
> with the scheduler maintainers anyway)
> Reviewed-by: Jan Beulich <jbeulich@suse.com>
Thanks,
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 34/47] xen/sched: add fall back to idle vcpu when scheduling unit
2019-09-25 13:11 ` Jan Beulich
@ 2019-09-25 13:15 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 13:15 UTC (permalink / raw)
To: Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli, Volodymyr Babchuk,
Roger Pau Monné
On 25.09.19 15:11, Jan Beulich wrote:
> On 25.09.2019 14:58, Jürgen Groß wrote:
>> On 24.09.19 12:53, Jan Beulich wrote:
>>> On 14.09.2019 10:52, Juergen Gross wrote:
>>>> @@ -2015,7 +2079,8 @@ static void sched_slave(void)
>>>>
>>>> pcpu_schedule_unlock_irq(lock, cpu);
>>>>
>>>> - sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu), now);
>>>> + sched_context_switch(vprev, sched_unit2vcpu_cpu(next, cpu),
>>>> + is_idle_unit(next) && !is_idle_unit(prev), now);
>>>> }
>>>>
>>>> /*
>>>> @@ -2075,7 +2140,8 @@ static void schedule(void)
>>>> pcpu_schedule_unlock_irq(lock, cpu);
>>>>
>>>> vnext = sched_unit2vcpu_cpu(next, cpu);
>>>> - sched_context_switch(vprev, vnext, now);
>>>> + sched_context_switch(vprev, vnext,
>>>> + !is_idle_unit(prev) && is_idle_unit(next), now);
>>>> }
>>>
>>> As a minor remark, I think between such constructs it would be good
>>> if there was no difference, unless there's a reason to have one. Yet
>>> if there was a reason, it surely would want to be spelled out.
>>
>> I guess you mean changing the parameters of sched_context_switch()? I
>> can do that.
>
> Well, yes, the two sides of the && in one of them.
Ah, okay.
>
>>>> --- a/xen/include/asm-x86/smp.h
>>>> +++ b/xen/include/asm-x86/smp.h
>>>> @@ -76,6 +76,9 @@ void set_nr_sockets(void);
>>>> /* Representing HT and core siblings in each socket. */
>>>> extern cpumask_t **socket_cpumask;
>>>>
>>>> +#define get_cpu_current(cpu) \
>>>> + (get_cpu_info_from_stack((unsigned long)stack_base[cpu])->current_vcpu)
>>>
>>> I don't think this can go without a comment clarifying under what
>>> (pretty narrow I think) conditions this is legitimate to use.
>>
>> Okay. I'll add a comment like: "to be used only while no context switch
>> can occur on the cpu".
>
> To be crystal clear, I'd append ", i.e. by certain scheduling code only".
Fine with me.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 36/47] xen/sched: carve out freeing sched_unit memory into dedicated function
2019-09-25 13:09 ` Jürgen Groß
@ 2019-09-25 13:16 ` Jan Beulich
2019-09-25 17:31 ` Dario Faggioli
0 siblings, 1 reply; 161+ messages in thread
From: Jan Beulich @ 2019-09-25 13:16 UTC (permalink / raw)
To: Jürgen Groß; +Cc: George Dunlap, xen-devel, Dario Faggioli
On 25.09.2019 15:09, Jürgen Groß wrote:
> On 24.09.19 14:04, Jan Beulich wrote:
>> On 14.09.2019 10:52, Juergen Gross wrote:
>>> --- a/xen/common/schedule.c
>>> +++ b/xen/common/schedule.c
>>> @@ -351,26 +351,10 @@ static void sched_spin_unlock_double(spinlock_t *lock1, spinlock_t *lock2,
>>> spin_unlock_irqrestore(lock1, flags);
>>> }
>>>
>>> -static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
>>> +static void sched_free_unit_mem(struct sched_unit *unit)
>>> {
>>> struct sched_unit *prev_unit;
>>> struct domain *d = unit->domain;
>>> - struct vcpu *vunit;
>>> - unsigned int cnt = 0;
>>> -
>>> - /* Don't count to be released vcpu, might be not in vcpu list yet. */
>>> - for_each_sched_unit_vcpu ( unit, vunit )
>>> - if ( vunit != v )
>>> - cnt++;
>>> -
>>> - v->sched_unit = NULL;
>>> - unit->runstate_cnt[v->runstate.state]--;
>>> -
>>> - if ( cnt )
>>> - return;
>>> -
>>> - if ( unit->vcpu_list == v )
>>> - unit->vcpu_list = v->next_in_list;
>>>
>>> if ( d->sched_unit_list == unit )
>>> d->sched_unit_list = unit->next_in_list;
>>> @@ -393,6 +377,26 @@ static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
>>> xfree(unit);
>>> }
>>>
>>> +static void sched_free_unit(struct sched_unit *unit, struct vcpu *v)
>>> +{
>>> + struct vcpu *vunit;
>>> + unsigned int cnt = 0;
>>> +
>>> + /* Don't count to be released vcpu, might be not in vcpu list yet. */
>>> + for_each_sched_unit_vcpu ( unit, vunit )
>>> + if ( vunit != v )
>>> + cnt++;
>>> +
>>> + v->sched_unit = NULL;
>>> + unit->runstate_cnt[v->runstate.state]--;
>>> +
>>> + if ( unit->vcpu_list == v )
>>> + unit->vcpu_list = v->next_in_list;
>>> +
>>> + if ( !cnt )
>>> + sched_free_unit_mem(unit);
>>> +}
>>
>> The entire sched_free_unit() is new code (starting from patch 3) - why
>> don't you arrange for the split right away, instead of moving code
>> around here?
>
> I wanted to introduce new subfunctions only when they are really needed.
There are cases where this is indeed the better approach; perhaps
that even the typical case. But here you spend an entire patch on
re-doing what you've done before. So ...
> I can merge this patch into patch 3 if you like that better.
... yes, personally I'd prefer this, but in the end it's the call
of the scheduler maintainers.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 38/47] xen/sched: move per-cpu variable cpupool to struct sched_resource
2019-09-24 13:10 ` Jan Beulich
@ 2019-09-25 13:17 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 13:17 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, Meng Xu, xen-devel
On 24.09.19 15:10, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> Having a pointer to struct cpupool in struct sched_resource instead
>> of per cpu is enough.
>>
>> Signed-off-by: Juergen Gross <jgross@suse.com>
>
> Technically / mechanically
> Reviewed-by: Jan Beulich <jbeulich@suse.com>
>
> However, I'm confused by what appears to be a resulting chicken-and-
> egg problem when considering the plan of allowing different
> granularities in different cpupools. Perhaps I'm either mis-
> remembering that plan, or it's not clear to me how data would get
> structured in that case.
There still is:
DEFINE_PER_CPU_READ_MOSTLY(struct sched_resource *, sched_res);
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 15/47] xen/sched: make rt scheduler vcpu agnostic.
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 15/47] xen/sched: make rt " Juergen Gross
@ 2019-09-25 13:20 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 13:20 UTC (permalink / raw)
To: Juergen Gross, xen-devel; +Cc: George Dunlap, Meng Xu
[-- Attachment #1.1: Type: text/plain, Size: 1765 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Switch rt scheduler completely from vcpu to sched_unit usage.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
With just one additional note.
> * This scheduler follows the Preemptive Global Earliest Deadline
> First (EDF)
> * theory in real-time field.
> - * At any scheduling point, the VCPU with earlier deadline has
> higher priority.
> - * The scheduler always picks highest priority VCPU to run on a
> feasible PCPU.
> - * A PCPU is feasible if the VCPU can run on this PCPU and (the PCPU
> is idle or
> - * has a lower-priority VCPU running on it.)
> + * At any scheduling point, the UNIT with earlier deadline has
> higher priority.
>
From the real-time scheduling theory point of view, whether this really
makes sense (i.e., it still makes it possible to provide real-time
scheduling guarantees to guests, and if yes, how) has to be thought and
considered.
But this of course applies to the case when core-scheduling is actually
used, which is not (at least by default) for now. Moreover, we're
planning to make it possible to have it enabled on a per-pool basis,
which means it will be possible to have sched_rt cpupools with core
scheduling disabled.
On this grounds, I'm ok with the changes to this scheduler. When the
series is in, I'll add a note to this respect in some sched_rt related
piece of documentation.
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 40/47] xen/sched: prepare per-cpupool scheduling granularity
2019-09-24 13:34 ` Jan Beulich
@ 2019-09-25 13:31 ` Jürgen Groß
2019-09-26 9:41 ` Dario Faggioli
1 sibling, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 13:31 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 24.09.19 15:34, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> --- a/xen/common/cpupool.c
>> +++ b/xen/common/cpupool.c
>> @@ -175,6 +175,8 @@ static struct cpupool *cpupool_create(
>> return NULL;
>> }
>> }
>> + c->granularity = sched_granularity;
>> + c->opt_granularity = opt_sched_granularity;
>>
>> *q = c;
>>
>> diff --git a/xen/common/schedule.c b/xen/common/schedule.c
>> index e5b7678dc0..b3c1aa0821 100644
>> --- a/xen/common/schedule.c
>> +++ b/xen/common/schedule.c
>> @@ -56,7 +56,8 @@ int sched_ratelimit_us = SCHED_DEFAULT_RATELIMIT_US;
>> integer_param("sched_ratelimit_us", sched_ratelimit_us);
>>
>> /* Number of vcpus per struct sched_unit. */
>> -static unsigned int __read_mostly sched_granularity = 1;
>> +enum sched_gran __read_mostly opt_sched_granularity = SCHED_GRAN_cpu;
>> +unsigned int __read_mostly sched_granularity = 1;
>
> Seeing the replacements you do further down, are these variables
> needed at all anymore outside of cpupool.c? If not, they should
> probably move there, and remain / become static?
Hmm, good idea.
>
>> --- a/xen/include/xen/sched-if.h
>> +++ b/xen/include/xen/sched-if.h
>> @@ -25,6 +25,15 @@ extern int sched_ratelimit_us;
>> /* Scheduling resource mask. */
>> extern const cpumask_t *sched_res_mask;
>>
>> +/* Number of vcpus per struct sched_unit. */
>> +enum sched_gran {
>> + SCHED_GRAN_cpu,
>> + SCHED_GRAN_core,
>> + SCHED_GRAN_socket
>> +};
>
> Seeing the almost absurd arrangement on my AMD Fam17 system (128 CPUs
> per Credit2 runqueue, for a total of two runqueues) I really wonder
> whether there shouldn't be a plan for a further intermediate
> granularity between "core" and "socket". The other day I did notice
> Linux has gained the concept of "die", which would bring the
> arrangement to a more reasonable 8 runqueues of 32 CPUs each on this
> system. (I'm taking Credit2 as a reference here only.)
Okay, another item for "scheduler cleanup" I guess.
>
>> @@ -532,6 +542,8 @@ struct cpupool
>> struct cpupool *next;
>> struct scheduler *sched;
>> atomic_t refcnt;
>> + unsigned int granularity;
>> + enum sched_gran opt_granularity;
>
> I'd like to suggest to avoid introducing opt_* identifiers not
> directly driven by command line options. That'll just end up
> confusing people. I have to admit I'm having trouble coming up with
> good names for both fields, so I'd like to ask whether you really
> need both - isn't what's called "granularity" above a function of
> "opt_granularity"?
Only indirectly. I need opt_granularity for selecting the correct
cpumask (cpumask_of(), cpu_sibling_mask(), ...). granularity is the
numerical value which I don't want to calculate each time I need it.
> Or alternatively couldn't what's named
> "granularity" now be always taken from struct sched_resource? I
> take it that within a pool all struct sched_resource instances
> would have the same numeric granularity value. And I further take
> it that struct sched_resource instances won't freely move between
> cpupools (and hence could e.g. be associated with their pool on
> linked list, the head of which lives in struct cpupool).
I think I wouldn't need such a linked list. All cases where I need
cpupool->granularity are not performance critical, so I could easily
calculate it from cpupool->opt_granularity or by using
cpupool->res_valid for finding a sched_resource of that cpupool.
I'll rename cpupool->opt_granularity to gran and drop
cpupool->granularity.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 43/47] xen/sched: support multiple cpus per scheduling resource
2019-09-24 13:49 ` Jan Beulich
@ 2019-09-25 13:39 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 13:39 UTC (permalink / raw)
To: Jan Beulich
Cc: Tim Deegan, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Dario Faggioli,
Julien Grall, xen-devel
On 24.09.19 15:49, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
>> --- a/xen/common/schedule.c
>> +++ b/xen/common/schedule.c
>> @@ -59,7 +59,7 @@ integer_param("sched_ratelimit_us", sched_ratelimit_us);
>> enum sched_gran __read_mostly opt_sched_granularity = SCHED_GRAN_cpu;
>> unsigned int __read_mostly sched_granularity = 1;
>> bool __read_mostly sched_disable_smt_switching;
>> -const cpumask_t *sched_res_mask = &cpumask_all;
>> +cpumask_var_t sched_res_mask;
>
> For a non-automatic variable it might be even easier to have it
> be cpumask_t?
I can change that.
>
>> @@ -2401,6 +2407,8 @@ static int cpu_schedule_up(unsigned int cpu)
>> /* We start with cpu granularity. */
>> sd->granularity = 1;
>>
>> + cpumask_set_cpu(cpu, sched_res_mask);
>
> I'm missing the clearing counterpart.
Oh, indeed. Good catch! Not that it would result in wrong behavior,
though.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 18/47] xen/sched: make arinc653 scheduler vcpu agnostic.
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 18/47] xen/sched: make arinc653 " Juergen Gross
@ 2019-09-25 13:51 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 13:51 UTC (permalink / raw)
To: Juergen Gross, xen-devel; +Cc: George Dunlap, Josh Whitehead, Robert VanVossen
[-- Attachment #1.1: Type: text/plain, Size: 806 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Switch arinc653 scheduler completely from vcpu to sched_unit usage.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Similar considerations to the ones I made on sched_rt applies here, I
guess.
But again, as soon as core scheduling is not actually used, things
should be fine. And I'm less familiar with this scheduler than with the
others, so I'll leave any further analysis to the maintainers.
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 16/47] xen/sched: make credit scheduler vcpu agnostic.
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 16/47] xen/sched: make credit " Juergen Gross
@ 2019-09-25 14:21 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 14:21 UTC (permalink / raw)
To: Juergen Gross, xen-devel; +Cc: George Dunlap
[-- Attachment #1.1: Type: text/plain, Size: 516 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Switch credit scheduler completely from vcpu to sched_unit usage.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 17/47] xen/sched: make credit2 scheduler vcpu agnostic.
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 17/47] xen/sched: make credit2 " Juergen Gross
@ 2019-09-25 15:02 ` Dario Faggioli
2019-09-25 15:18 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 15:02 UTC (permalink / raw)
To: Juergen Gross, xen-devel; +Cc: George Dunlap
[-- Attachment #1.1: Type: text/plain, Size: 1002 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Switch credit2 scheduler completely from vcpu to sched_unit usage.
>
> As we are touching lots of lines remove some white space at the end
> of
> the line, too.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
I did spot another 'item' that wants to be turned into...
> diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
> index a6083289f6..0d1ba97dbc 100644
> --- a/xen/common/sched_credit2.c
> +++ b/xen/common/sched_credit2.c
>
> @@ -510,20 +510,20 @@ struct csched2_pcpu {
> };
>
> /*
> - * Virtual CPU
> + * Schedule Item
> */
>
... 'unit'. :-)
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 17/47] xen/sched: make credit2 scheduler vcpu agnostic.
2019-09-25 15:02 ` Dario Faggioli
@ 2019-09-25 15:18 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-25 15:18 UTC (permalink / raw)
To: Dario Faggioli, xen-devel; +Cc: George Dunlap
On 25.09.19 17:02, Dario Faggioli wrote:
> On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
>> Switch credit2 scheduler completely from vcpu to sched_unit usage.
>>
>> As we are touching lots of lines remove some white space at the end
>> of
>> the line, too.
>>
>> Signed-off-by: Juergen Gross <jgross@suse.com>
>>
> Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
>
> I did spot another 'item' that wants to be turned into...
>
>> diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c
>> index a6083289f6..0d1ba97dbc 100644
>> --- a/xen/common/sched_credit2.c
>> +++ b/xen/common/sched_credit2.c
>>
>> @@ -510,20 +510,20 @@ struct csched2_pcpu {
>> };
>>
>> /*
>> - * Virtual CPU
>> + * Schedule Item
>> */
>>
> ... 'unit'. :-)
Yes, that was the test whether the review is done thoroughly. ;-)
Thanks!
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 19/47] xen: add sched_unit_pause_nosync() and sched_unit_unpause()
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 19/47] xen: add sched_unit_pause_nosync() and sched_unit_unpause() Juergen Gross
@ 2019-09-25 15:20 ` Dario Faggioli
2019-09-26 4:49 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 15:20 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Julien Grall,
Jan Beulich, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 1405 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> The credit scheduler calls vcpu_pause_nosync() and vcpu_unpause()
> today.
>
It does. And, FWIW, I hate it with all my heart because of that (among
other things! :-D).
> Add sched_unit_pause_nosync() and sched_unit_unpause() to
> perform the same operations on scheduler units instead.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
> diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
> index d624b81e53..b5967d26af 100644
> --- a/xen/include/xen/sched-if.h
> +++ b/xen/include/xen/sched-if.h
> @@ -432,6 +432,16 @@ static inline int sched_adjust_cpupool(const
> struct scheduler *s,
> return s->adjust_global ? s->adjust_global(s, op) : 0;
> }
>
> +static inline void sched_unit_pause_nosync(struct sched_unit *unit)
> +{
> + vcpu_pause_nosync(unit->vcpu_list);
> +}
> +
> +static inline void sched_unit_unpause(struct sched_unit *unit)
> +{
> + vcpu_unpause(unit->vcpu_list);
> +}
> +
So, isn't this another one of those places where we could have the
for_each_unit_vcpu() loop already?
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 12/47] xen/sched: switch struct task_slice from vcpu to sched_unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 12/47] xen/sched: switch struct task_slice from vcpu to sched_unit Juergen Gross
@ 2019-09-25 15:23 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 15:23 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Robert VanVossen,
Julien Grall, Josh Whitehead, Meng Xu, Jan Beulich, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 547 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Let the schedulers put a sched_unit pointer into struct task_slice
> instead of a vcpu pointer.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit Juergen Gross
2019-09-19 15:53 ` Jan Beulich
@ 2019-09-25 15:27 ` Dario Faggioli
1 sibling, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 15:27 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Julien Grall, Meng Xu,
Jan Beulich, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 888 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Add an is_running indicator to struct sched_unit which will be set
> whenever the unit is being scheduled. Switch scheduler code to use
> unit->is_running instead of vcpu->is_running for scheduling
> decisions.
>
> At the same time introduce a state_entry_time field in struct
> sched_unit being updated whenever the is_running indicator is
> changed.
> Use that new field in the schedulers instead of the similar vcpu
> field.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 46/47] xen/sched: disable scheduling when entering ACPI deep sleep states
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 46/47] xen/sched: disable scheduling when entering ACPI deep sleep states Juergen Gross
@ 2019-09-25 16:02 ` Jan Beulich
2019-09-26 9:41 ` Dario Faggioli
1 sibling, 0 replies; 161+ messages in thread
From: Jan Beulich @ 2019-09-25 16:02 UTC (permalink / raw)
To: Juergen Gross
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel, Dario Faggioli, Roger Pau Monné
On 14.09.2019 10:52, Juergen Gross wrote:
> When entering deep sleep states all domains are paused resulting in
> all cpus only running idle vcpus. This enables us to stop scheduling
> completely in order to avoid synchronization problems with core
> scheduling when individual cpus are offlined.
>
> Disabling the scheduler is done by replacing the softirq handler
> with a dummy scheduling routine only enabling tasklets to run.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
> ---
> V2: new patch
> ---
> xen/arch/x86/acpi/power.c | 4 ++++
The minimal changes here
Acked-by: Jan Beulich <jbeulich@suse.com>
> +void scheduler_disable(void)
> +{
> + scheduler_active = false;
> + open_softirq(SCHEDULE_SOFTIRQ, schedule_dummy);
> + open_softirq(SCHED_SLAVE_SOFTIRQ, schedule_dummy);
> +}
> +
> +void scheduler_enable(void)
> +{
> + open_softirq(SCHEDULE_SOFTIRQ, schedule);
> + open_softirq(SCHED_SLAVE_SOFTIRQ, sched_slave);
> + scheduler_active = true;
> +}
I have to admit I find the behavior of open_softirq() odd that
you make use of here, i.e. I'm not convinced you should rely on
the function not gaining a check refusing the operation if a
handler is already in place. Otoh I see that even in up-to-date
Linux this works the same.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 20/47] xen: let vcpu_create() select processor
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 20/47] xen: let vcpu_create() select processor Juergen Gross
@ 2019-09-25 16:31 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 16:31 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, Jan Beulich, Volodymyr Babchuk,
Roger Pau Monné
[-- Attachment #1.1: Type: text/plain, Size: 1638 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Today there are two distinct scenarios for vcpu_create(): either for
> creation of idle-domain vcpus (vcpuid == processor) or for creation
> of
> "normal" domain vcpus (including dom0), where the caller selects the
> initial processor on a round-robin scheme of the allowed processors
> (allowed being based on cpupool and affinities).
>
> Instead of passing the initial processor to vcpu_create() and passing
> on to sched_init_vcpu() let sched_init_vcpu() do the processor
> selection. For supporting dom0 vcpu creation use the node_affinity of
> the domain as a base for selecting the processors. User domains will
> have initially all nodes set, so this is no different behavior
> compared
> to today. In theory this is not guaranteed as vcpus are created only
> with XEN_DOMCTL_max_vcpus being called, but this call is going to be
> removed in future and the toolstack doesn't call
> XEN_DOMCTL_setnodeaffinity before calling XEN_DOMCTL_max_vcpus.
>
> To be able to use const struct domain * make cpupool_domain_cpumask()
> take a const domain pointer, too.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
> Acked-by: Andrew Cooper <andrew.cooper3@citrix.com>
> Acked-by: Julien Grall <julien.grall@arm.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 22/47] xen/sched: switch schedule() from vcpus to sched_units
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 22/47] xen/sched: switch schedule() from vcpus to sched_units Juergen Gross
@ 2019-09-25 16:34 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 16:34 UTC (permalink / raw)
To: Juergen Gross, xen-devel; +Cc: George Dunlap
[-- Attachment #1.1: Type: text/plain, Size: 625 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Use sched_units instead of vcpus in schedule(). This includes the
> introduction of sched_unit_runstate_change() as a replacement of
> vcpu_runstate_change() in schedule().
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 26/47] xen/sched: Change vcpu_migrate_*() to operate on schedule unit
2019-09-25 12:04 ` Jürgen Groß
@ 2019-09-25 16:37 ` Dario Faggioli
2019-09-26 4:51 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 16:37 UTC (permalink / raw)
To: Jürgen Groß, xen-devel; +Cc: George Dunlap
[-- Attachment #1.1: Type: text/plain, Size: 1159 bytes --]
On Wed, 2019-09-25 at 14:04 +0200, Jürgen Groß wrote:
> On 25.09.19 00:33, Dario Faggioli wrote:
> >
> > > As it is needed anyway call vcpu_sync_execstate() for each
> > > vcpu of the unit when changing processors.
> > >
> > Again, what do you mean with "As it is needed anyway"?
>
> When moving from one cpu to another one the state must be saved in
> struct vcpu (in contrast to being held partially in registers or on
> the
> stack in case only the idle vcpu was scheduled afterwards on the old
> cpu).
>
Sure.
> This is done by vcpu_sync_execstate(). Without the explicit call
> it would be done either when the vcpu is being scheduled on the new
> cpu
> or if another non-idle vcpu is becoming active on the old cpu.
>
Right. And does this then means that we're now doing it twice (i.e.,
here and either of the other places you mentioned)?
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 36/47] xen/sched: carve out freeing sched_unit memory into dedicated function
2019-09-25 13:16 ` Jan Beulich
@ 2019-09-25 17:31 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-25 17:31 UTC (permalink / raw)
To: Jan Beulich, Jürgen Groß; +Cc: George Dunlap, xen-devel
[-- Attachment #1.1: Type: text/plain, Size: 815 bytes --]
On Wed, 2019-09-25 at 15:16 +0200, Jan Beulich wrote:
> On 25.09.2019 15:09, Jürgen Groß wrote:
> >
> There are cases where this is indeed the better approach; perhaps
> that even the typical case. But here you spend an entire patch on
> re-doing what you've done before. So ...
>
> > I can merge this patch into patch 3 if you like that better.
>
> ... yes, personally I'd prefer this, but in the end it's the call
> of the scheduler maintainers.
>
Yes, I think I like it better too for the patches to be merged.
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 19/47] xen: add sched_unit_pause_nosync() and sched_unit_unpause()
2019-09-25 15:20 ` Dario Faggioli
@ 2019-09-26 4:49 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-26 4:49 UTC (permalink / raw)
To: Dario Faggioli, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Julien Grall,
Jan Beulich, Ian Jackson
On 25.09.19 17:20, Dario Faggioli wrote:
> On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
>> The credit scheduler calls vcpu_pause_nosync() and vcpu_unpause()
>> today.
>>
> It does. And, FWIW, I hate it with all my heart because of that (among
> other things! :-D).
>
>> Add sched_unit_pause_nosync() and sched_unit_unpause() to
>> perform the same operations on scheduler units instead.
>>
>> Signed-off-by: Juergen Gross <jgross@suse.com>
>>
>> diff --git a/xen/include/xen/sched-if.h b/xen/include/xen/sched-if.h
>> index d624b81e53..b5967d26af 100644
>> --- a/xen/include/xen/sched-if.h
>> +++ b/xen/include/xen/sched-if.h
>> @@ -432,6 +432,16 @@ static inline int sched_adjust_cpupool(const
>> struct scheduler *s,
>> return s->adjust_global ? s->adjust_global(s, op) : 0;
>> }
>>
>> +static inline void sched_unit_pause_nosync(struct sched_unit *unit)
>> +{
>> + vcpu_pause_nosync(unit->vcpu_list);
>> +}
>> +
>> +static inline void sched_unit_unpause(struct sched_unit *unit)
>> +{
>> + vcpu_unpause(unit->vcpu_list);
>> +}
>> +
> So, isn't this another one of those places where we could have the
> for_each_unit_vcpu() loop already?
Yes.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 26/47] xen/sched: Change vcpu_migrate_*() to operate on schedule unit
2019-09-25 16:37 ` Dario Faggioli
@ 2019-09-26 4:51 ` Jürgen Groß
2019-09-26 13:29 ` Dario Faggioli
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-26 4:51 UTC (permalink / raw)
To: Dario Faggioli, xen-devel; +Cc: George Dunlap
On 25.09.19 18:37, Dario Faggioli wrote:
> On Wed, 2019-09-25 at 14:04 +0200, Jürgen Groß wrote:
>> On 25.09.19 00:33, Dario Faggioli wrote:
>>>
>>>> As it is needed anyway call vcpu_sync_execstate() for each
>>>> vcpu of the unit when changing processors.
>>>>
>>> Again, what do you mean with "As it is needed anyway"?
>>
>> When moving from one cpu to another one the state must be saved in
>> struct vcpu (in contrast to being held partially in registers or on
>> the
>> stack in case only the idle vcpu was scheduled afterwards on the old
>> cpu).
>>
> Sure.
>
>> This is done by vcpu_sync_execstate(). Without the explicit call
>> it would be done either when the vcpu is being scheduled on the new
>> cpu
>> or if another non-idle vcpu is becoming active on the old cpu.
>>
> Right. And does this then means that we're now doing it twice (i.e.,
> here and either of the other places you mentioned)?
No, it checks whether it has to do anything.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 37/47] xen/sched: move per-cpu variable scheduler to struct sched_resource
2019-09-25 13:13 ` Jürgen Groß
@ 2019-09-26 9:06 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 9:06 UTC (permalink / raw)
To: Jürgen Groß, Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Julien Grall,
xen-devel, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 930 bytes --]
On Wed, 2019-09-25 at 15:13 +0200, Jürgen Groß wrote:
> On 24.09.19 14:16, Jan Beulich wrote:
> >
> > While at the first glance "sd" is used twice here, this 2nd use is
> > actually unnecessary - "cpu" hasn't changed from the beginning of
> > the function afaics, and hence "ops" could be used here.
>
> "sd" is now "sr" everywhere.
>
> And yes, using ops here seems okay.
>
> > Preferably with the suggested adjustments (but final judgement is
> > with the scheduler maintainers anyway)
> > Reviewed-by: Jan Beulich <jbeulich@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
(With sd->sr and with using ops.)
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 38/47] xen/sched: move per-cpu variable cpupool to struct sched_resource
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 38/47] xen/sched: move per-cpu variable cpupool " Juergen Gross
2019-09-24 13:10 ` Jan Beulich
@ 2019-09-26 9:09 ` Dario Faggioli
1 sibling, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 9:09 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Julien Grall, Meng Xu,
Jan Beulich, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 543 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Having a pointer to struct cpupool in struct sched_resource instead
> of per cpu is enough.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 39/47] xen/sched: reject switching smt on/off with core scheduling active
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 39/47] xen/sched: reject switching smt on/off with core scheduling active Juergen Gross
@ 2019-09-26 9:10 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 9:10 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, Jan Beulich, Roger Pau Monné
[-- Attachment #1.1: Type: text/plain, Size: 732 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> When core or socket scheduling are active enabling or disabling smt
> is
> not possible as that would require a major host reconfiguration.
>
> Add a bool sched_disable_smt_switching which will be set for core or
> socket scheduling.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
> Acked-by: Jan Beulich <jbeulich@suse.com>
>
Acked-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 40/47] xen/sched: prepare per-cpupool scheduling granularity
2019-09-24 13:34 ` Jan Beulich
2019-09-25 13:31 ` Jürgen Groß
@ 2019-09-26 9:41 ` Dario Faggioli
1 sibling, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 9:41 UTC (permalink / raw)
To: Jan Beulich, Juergen Gross
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Julien Grall,
xen-devel, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 2215 bytes --]
On Tue, 2019-09-24 at 15:34 +0200, Jan Beulich wrote:
> On 14.09.2019 10:52, Juergen Gross wrote:
> > --- a/xen/include/xen/sched-if.h
> > +++ b/xen/include/xen/sched-if.h
> > @@ -25,6 +25,15 @@ extern int sched_ratelimit_us;
> > /* Scheduling resource mask. */
> > extern const cpumask_t *sched_res_mask;
> >
> > +/* Number of vcpus per struct sched_unit. */
> > +enum sched_gran {
> > + SCHED_GRAN_cpu,
> > + SCHED_GRAN_core,
> > + SCHED_GRAN_socket
> > +};
>
> Seeing the almost absurd arrangement on my AMD Fam17 system (128 CPUs
> per Credit2 runqueue, for a total of two runqueues) I really wonder
> whether there shouldn't be a plan for a further intermediate
> granularity between "core" and "socket". The other day I did notice
> Linux has gained the concept of "die", which would bring the
> arrangement to a more reasonable 8 runqueues of 32 CPUs each on this
> system. (I'm taking Credit2 as a reference here only.)
>
The default Credit2 setup on such system does indeed make no sense.
Introducing DIE (or whatever we want to call it) granularity for
Credit2 runqueues, and, in general, doing something more clever when
deciding how many CPUs should end up in the same runqueue is definitely
something we want.
Actually, there are patches already for specifying, at boot time, a
totally arbitrary runqueue arrangement.... I just need to fish them
from the list, rebase and resubmit. This does not cover the case above,
as we will still need a more sensible default, but it goes in the right
direction, I think.
That's, however, something which although quite important for Credit2,
is less of a concern for core-scheduling. In fact, as said elsewhere
already, I really don't expect anyone to want to use either die-
scheduling, socket-scheduling or anything different than core-
scheduling anytime soon.
I'll look into the Credit2 runqueue issue (for 4.14).
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 46/47] xen/sched: disable scheduling when entering ACPI deep sleep states
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 46/47] xen/sched: disable scheduling when entering ACPI deep sleep states Juergen Gross
2019-09-25 16:02 ` Jan Beulich
@ 2019-09-26 9:41 ` Dario Faggioli
1 sibling, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 9:41 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, Jan Beulich, Roger Pau Monné
[-- Attachment #1.1: Type: text/plain, Size: 844 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> When entering deep sleep states all domains are paused resulting in
> all cpus only running idle vcpus. This enables us to stop scheduling
> completely in order to avoid synchronization problems with core
> scheduling when individual cpus are offlined.
>
> Disabling the scheduler is done by replacing the softirq handler
> with a dummy scheduling routine only enabling tasklets to run.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 47/47] xen/sched: add scheduling granularity enum
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 47/47] xen/sched: add scheduling granularity enum Juergen Gross
@ 2019-09-26 9:46 ` Dario Faggioli
2019-09-26 12:37 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 9:46 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, Jan Beulich, Roger Pau Monné
[-- Attachment #1.1: Type: text/plain, Size: 904 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Add a scheduling granularity enum ("cpu", "core", "socket") for
> specification of the scheduling granularity. Initially it is set to
> "cpu", this can be modified by the new boot parameter (x86 only)
> "sched-gran".
>
> According to the selected granularity sched_granularity is set after
> all cpus are online.
>
> A test is added for all sched resources holding the same number of
> cpus. Fall back to core- or cpu-scheduling in that case.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 21/47] xen/sched: use sched_resource cpu instead smp_processor_id in schedulers
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 21/47] xen/sched: use sched_resource cpu instead smp_processor_id in schedulers Juergen Gross
@ 2019-09-26 10:01 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 10:01 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Robert VanVossen,
Julien Grall, Josh Whitehead, Meng Xu, Jan Beulich, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 882 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> Especially in the do_schedule() functions of the different schedulers
> using smp_processor_id() for the local cpu number is correct only if
> the sched_unit is a single vcpu. As soon as larger sched_units are
> used most uses should be replaced by the master_cpu number of the
> local
> sched_resource instead.
>
> Add a helper to get that sched_resource master_cpu and modify the
> schedulers to use it in a correct way.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 27/47] xen/sched: move struct task_slice into struct sched_unit
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 27/47] xen/sched: move struct task_slice into struct sched_unit Juergen Gross
@ 2019-09-26 10:30 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 10:30 UTC (permalink / raw)
To: Juergen Gross, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Robert VanVossen,
Julien Grall, Josh Whitehead, Meng Xu, Jan Beulich, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 1081 bytes --]
On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> In order to prepare for multiple vcpus per schedule unit move struct
> task_slice in schedule() from the local stack into struct sched_unit
> of the currently running unit. To make access easier for the single
> schedulers add the pointer of the currently running unit as a
> parameter
> of do_schedule().
>
> While at it switch the tasklet_work_scheduled parameter of
> do_schedule() from bool_t to bool.
>
> As struct task_slice is only ever modified with the local schedule
> lock held it is safe to directly set the different units in struct
> sched_unit instead of using an on-stack copy for returning the data.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
>
Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 47/47] xen/sched: add scheduling granularity enum
2019-09-26 9:46 ` Dario Faggioli
@ 2019-09-26 12:37 ` Jürgen Groß
2019-09-26 16:21 ` Dario Faggioli
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-26 12:37 UTC (permalink / raw)
To: Dario Faggioli, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, Jan Beulich, Roger Pau Monné
On 26.09.19 11:46, Dario Faggioli wrote:
> On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
>> Add a scheduling granularity enum ("cpu", "core", "socket") for
>> specification of the scheduling granularity. Initially it is set to
>> "cpu", this can be modified by the new boot parameter (x86 only)
>> "sched-gran".
>>
>> According to the selected granularity sched_granularity is set after
>> all cpus are online.
>>
>> A test is added for all sched resources holding the same number of
>> cpus. Fall back to core- or cpu-scheduling in that case.
>>
>> Signed-off-by: Juergen Gross <jgross@suse.com>
>>
> Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
Does this still stand with moving all code of this patch to
cpupool.c? That would avoid making some variables/functions globally
visible.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 26/47] xen/sched: Change vcpu_migrate_*() to operate on schedule unit
2019-09-26 4:51 ` Jürgen Groß
@ 2019-09-26 13:29 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 13:29 UTC (permalink / raw)
To: Jürgen Groß, xen-devel; +Cc: George Dunlap
[-- Attachment #1.1: Type: text/plain, Size: 895 bytes --]
On Thu, 2019-09-26 at 06:51 +0200, Jürgen Groß wrote:
> On 25.09.19 18:37, Dario Faggioli wrote:
> > > This is done by vcpu_sync_execstate(). Without the explicit call
> > > it would be done either when the vcpu is being scheduled on the
> > > new
> > > cpu
> > > or if another non-idle vcpu is becoming active on the old cpu.
> > >
> > Right. And does this then means that we're now doing it twice
> > (i.e.,
> > here and either of the other places you mentioned)?
>
> No, it checks whether it has to do anything.
>
Which I knew, but keep forgetting. :-(
Thanks, and sorry for the noise.
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-25 13:07 ` Jan Beulich
@ 2019-09-26 13:53 ` Dario Faggioli
2019-09-26 14:24 ` Jan Beulich
2019-09-26 14:40 ` Jürgen Groß
0 siblings, 2 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 13:53 UTC (permalink / raw)
To: Jan Beulich, Jürgen Groß, George Dunlap
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
Andrew Cooper, Tim Deegan, Julien Grall, xen-devel, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 2428 bytes --]
On Wed, 2019-09-25 at 15:07 +0200, Jan Beulich wrote:
> On 25.09.2019 14:40, Jürgen Groß wrote:
> > On 24.09.19 17:22, Jan Beulich wrote:
> > > On 24.09.2019 17:09, Jürgen Groß wrote:
> > > > On 24.09.19 17:00, Jan Beulich wrote:
> > > > > On 24.09.2019 16:41, Jürgen Groß wrote:
> > > > > > for_each_sched_unit_vcpu() for an idle
> > > > > > unit might end premature when one of the vcpus is running
> > > > > > in another
> > > > > > unit (idle_vcpu->sched_unit != idle_unit).
> > > > >
> > > > > Oh, that (v)->sched_unit == (i) in the construct is clearly
> > > > > unexpected.
> > > > > Is this really still needed by the end of the series? I
> > > > > realize that
> > > > > _some_ check is needed, but could this perhaps be arranged in
> > > > > a way
> > > > > that you'd still hit all vCPU-s when using it on an idle
> > > > > unit, no
> > > > > matter whether they're in use as a substitute in a "real"
> > > > > unit?
> > > >
> > > > I could do that by having another linked list in struct vcpu.
> > > > This way
> > > > I can avoid it.
> > >
> > > Oh, no, not another list just for this purpose. I was rather
> > > thinking
> > > of e.g. a comparison of IDs.
> >
> > That would result either in something like:
> >
> > (v)->vcpu_id < (u)->unit_id + (u)->res->cpupool->granularity
> >
> > requiring to make struct sched_resource public as keyhandler.c
> > needs
> > for_each_sched_unit_vcpu() plus being quite expensive,
>
> I agree this is not a good option.
>
> > or:
> >
> > !(u)->next_in_list || (v)->vcpu_id < (u)->next_in_list->unit_id
> >
> > which seems to be more expensive as the current variant, too.
>
> It's not this much more expensive, and it eliminates unexpected
> (as I would call it) behavior, so I think I'd go this route.
>
So, I honestly like the way it's currently done in Juergen's pathes.
However, I'm not sure I understand what it is the issue that Jan thinks
that has, and in what sense the code/behavior is regarded as
"unexpected".
Can you help me see the problem? Maybe, if I realize it, I'd change my
preference...
Thanks and Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-26 13:53 ` Dario Faggioli
@ 2019-09-26 14:24 ` Jan Beulich
2019-09-26 14:40 ` Jürgen Groß
1 sibling, 0 replies; 161+ messages in thread
From: Jan Beulich @ 2019-09-26 14:24 UTC (permalink / raw)
To: Dario Faggioli
Cc: Jürgen Groß,
Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, xen-devel
On 26.09.2019 15:53, Dario Faggioli wrote:
> On Wed, 2019-09-25 at 15:07 +0200, Jan Beulich wrote:
>> On 25.09.2019 14:40, Jürgen Groß wrote:
>>> On 24.09.19 17:22, Jan Beulich wrote:
>>>> On 24.09.2019 17:09, Jürgen Groß wrote:
>>>>> On 24.09.19 17:00, Jan Beulich wrote:
>>>>>> On 24.09.2019 16:41, Jürgen Groß wrote:
>>>>>>> for_each_sched_unit_vcpu() for an idle
>>>>>>> unit might end premature when one of the vcpus is running
>>>>>>> in another
>>>>>>> unit (idle_vcpu->sched_unit != idle_unit).
>>>>>>
>>>>>> Oh, that (v)->sched_unit == (i) in the construct is clearly
>>>>>> unexpected.
>>>>>> Is this really still needed by the end of the series? I
>>>>>> realize that
>>>>>> _some_ check is needed, but could this perhaps be arranged in
>>>>>> a way
>>>>>> that you'd still hit all vCPU-s when using it on an idle
>>>>>> unit, no
>>>>>> matter whether they're in use as a substitute in a "real"
>>>>>> unit?
>>>>>
>>>>> I could do that by having another linked list in struct vcpu.
>>>>> This way
>>>>> I can avoid it.
>>>>
>>>> Oh, no, not another list just for this purpose. I was rather
>>>> thinking
>>>> of e.g. a comparison of IDs.
>>>
>>> That would result either in something like:
>>>
>>> (v)->vcpu_id < (u)->unit_id + (u)->res->cpupool->granularity
>>>
>>> requiring to make struct sched_resource public as keyhandler.c
>>> needs
>>> for_each_sched_unit_vcpu() plus being quite expensive,
>>
>> I agree this is not a good option.
>>
>>> or:
>>>
>>> !(u)->next_in_list || (v)->vcpu_id < (u)->next_in_list->unit_id
>>>
>>> which seems to be more expensive as the current variant, too.
>>
>> It's not this much more expensive, and it eliminates unexpected
>> (as I would call it) behavior, so I think I'd go this route.
>>
> So, I honestly like the way it's currently done in Juergen's pathes.
>
> However, I'm not sure I understand what it is the issue that Jan thinks
> that has, and in what sense the code/behavior is regarded as
> "unexpected".
>
> Can you help me see the problem? Maybe, if I realize it, I'd change my
> preference...
The unexpected / surprising behavior is described at the top (i.e.
still visible in context), but I'll quote it again here:
"for_each_sched_unit_vcpu() for an idle unit might end premature
when one of the vcpus is running in another unit
(idle_vcpu->sched_unit != idle_unit)"
This started out with me asking about an apparently (but as
Jürgen has clarified not truly) unnecessary special casing of
idle vCPU-s/units/domain ahead of a use of this construct.
Jan
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-26 13:53 ` Dario Faggioli
2019-09-26 14:24 ` Jan Beulich
@ 2019-09-26 14:40 ` Jürgen Groß
2019-09-26 16:41 ` Dario Faggioli
1 sibling, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-26 14:40 UTC (permalink / raw)
To: Dario Faggioli, Jan Beulich, George Dunlap
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
Andrew Cooper, Tim Deegan, Julien Grall, xen-devel, Ian Jackson
On 26.09.19 15:53, Dario Faggioli wrote:
> On Wed, 2019-09-25 at 15:07 +0200, Jan Beulich wrote:
>> On 25.09.2019 14:40, Jürgen Groß wrote:
>>> On 24.09.19 17:22, Jan Beulich wrote:
>>>> On 24.09.2019 17:09, Jürgen Groß wrote:
>>>>> On 24.09.19 17:00, Jan Beulich wrote:
>>>>>> On 24.09.2019 16:41, Jürgen Groß wrote:
>>>>>>> for_each_sched_unit_vcpu() for an idle
>>>>>>> unit might end premature when one of the vcpus is running
>>>>>>> in another
>>>>>>> unit (idle_vcpu->sched_unit != idle_unit).
>>>>>>
>>>>>> Oh, that (v)->sched_unit == (i) in the construct is clearly
>>>>>> unexpected.
>>>>>> Is this really still needed by the end of the series? I
>>>>>> realize that
>>>>>> _some_ check is needed, but could this perhaps be arranged in
>>>>>> a way
>>>>>> that you'd still hit all vCPU-s when using it on an idle
>>>>>> unit, no
>>>>>> matter whether they're in use as a substitute in a "real"
>>>>>> unit?
>>>>>
>>>>> I could do that by having another linked list in struct vcpu.
>>>>> This way
>>>>> I can avoid it.
>>>>
>>>> Oh, no, not another list just for this purpose. I was rather
>>>> thinking
>>>> of e.g. a comparison of IDs.
>>>
>>> That would result either in something like:
>>>
>>> (v)->vcpu_id < (u)->unit_id + (u)->res->cpupool->granularity
>>>
>>> requiring to make struct sched_resource public as keyhandler.c
>>> needs
>>> for_each_sched_unit_vcpu() plus being quite expensive,
>>
>> I agree this is not a good option.
>>
>>> or:
>>>
>>> !(u)->next_in_list || (v)->vcpu_id < (u)->next_in_list->unit_id
>>>
>>> which seems to be more expensive as the current variant, too.
>>
>> It's not this much more expensive, and it eliminates unexpected
>> (as I would call it) behavior, so I think I'd go this route.
>>
> So, I honestly like the way it's currently done in Juergen's pathes.
>
> However, I'm not sure I understand what it is the issue that Jan thinks
> that has, and in what sense the code/behavior is regarded as
> "unexpected".
>
> Can you help me see the problem? Maybe, if I realize it, I'd change my
> preference...
I have changed it meanwhile and I think the new solution removes a
latent problem. Otherwise one would have to be very careful not to use
for_each_sched_unit_vcpu() for idle units, as this might result in
occasional wrong results.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 47/47] xen/sched: add scheduling granularity enum
2019-09-26 12:37 ` Jürgen Groß
@ 2019-09-26 16:21 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 16:21 UTC (permalink / raw)
To: Jürgen Groß, xen-devel
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan,
Julien Grall, Jan Beulich, Roger Pau Monné
[-- Attachment #1.1: Type: text/plain, Size: 1498 bytes --]
On Thu, 2019-09-26 at 14:37 +0200, Jürgen Groß wrote:
> On 26.09.19 11:46, Dario Faggioli wrote:
> > On Sat, 2019-09-14 at 10:52 +0200, Juergen Gross wrote:
> > > Add a scheduling granularity enum ("cpu", "core", "socket") for
> > > specification of the scheduling granularity. Initially it is set
> > > to
> > > "cpu", this can be modified by the new boot parameter (x86 only)
> > > "sched-gran".
> > >
> > > According to the selected granularity sched_granularity is set
> > > after
> > > all cpus are online.
> > >
> > > A test is added for all sched resources holding the same number
> > > of
> > > cpus. Fall back to core- or cpu-scheduling in that case.
> > >
> > > Signed-off-by: Juergen Gross <jgross@suse.com>
> > >
> > Reviewed-by: Dario Faggioli <dfaggioli@suse.com>
>
> Does this still stand with moving all code of this patch to
> cpupool.c? That would avoid making some variables/functions globally
> visible.
>
Yep, I saw this being discussed during review of other patches, but
forgot to mention it here, sorry.
Yes, I'm fine with that, and I'm fine with the consequences of doing
that on this patch (i.e., moving to cpupool.c).
The Reviewed-by still holds.
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing
2019-09-26 14:40 ` Jürgen Groß
@ 2019-09-26 16:41 ` Dario Faggioli
0 siblings, 0 replies; 161+ messages in thread
From: Dario Faggioli @ 2019-09-26 16:41 UTC (permalink / raw)
To: Jürgen Groß, Jan Beulich, George Dunlap
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
Andrew Cooper, Tim Deegan, Julien Grall, xen-devel, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 819 bytes --]
On Thu, 2019-09-26 at 16:40 +0200, Jürgen Groß wrote:
> On 26.09.19 15:53, Dario Faggioli wrote:
> > However, I'm not sure I understand what it is the issue that Jan
> > thinks
> > that has, and in what sense the code/behavior is regarded as
> > "unexpected".
> >
> > Can you help me see the problem? Maybe, if I realize it, I'd change
> > my
> > preference...
>
> I have changed it meanwhile and I think the new solution removes a
> latent problem.
>
Ok, I'll comment directly on the new shape of it then, I guess.
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 35/47] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware
2019-09-25 13:07 ` Jürgen Groß
@ 2019-09-27 4:42 ` Jürgen Groß
2019-09-27 7:32 ` Dario Faggioli
0 siblings, 1 reply; 161+ messages in thread
From: Jürgen Groß @ 2019-09-27 4:42 UTC (permalink / raw)
To: Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Dario Faggioli,
Julien Grall, xen-devel, Ian Jackson
On 25.09.19 15:07, Jürgen Groß wrote:
> On 24.09.19 13:55, Jan Beulich wrote:
>> On 14.09.2019 10:52, Juergen Gross wrote:
>>> @@ -765,16 +774,22 @@ void vcpu_wake(struct vcpu *v)
>>> {
>>> unsigned long flags;
>>> spinlock_t *lock;
>>> + struct sched_unit *unit = v->sched_unit;
>>> TRACE_2D(TRC_SCHED_WAKE, v->domain->domain_id, v->vcpu_id);
>>> - lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
>>> + lock = unit_schedule_lock_irqsave(unit, &flags);
>>> if ( likely(vcpu_runnable(v)) )
>>> {
>>> if ( v->runstate.state >= RUNSTATE_blocked )
>>> vcpu_runstate_change(v, RUNSTATE_runnable, NOW());
>>> - sched_wake(vcpu_scheduler(v), v->sched_unit);
>>> + sched_wake(vcpu_scheduler(v), unit);
>>
>> Is this correct / necessary when the unit is not asleep as a whole?
>> After all the corresponding sched_sleep() further up is called
>> conditionally only.
>
> Oh, indeed. Will change that.
It turned out this is not so easy at it seemed.
I encountered dom0 boot hangs with making the call conditional, even
when running in cpu scheduling mode. I guess the reason is that a vcpu
can call do_poll() which will try to put itself to sleep and in some
cases call vcpu_wake() in case the condition already changed. In that
case we need the sched_wake() call even if the unit is still running.
>>> @@ -2067,9 +2160,29 @@ static void sched_slave(void)
>>> now = NOW();
>>> + v = unit2vcpu_cpu(prev, cpu);
>>> + if ( v && v->force_context_switch )
>>> + {
>>> + v = sched_force_context_switch(vprev, v, cpu, now);
>>> +
>>> + if ( v )
>>> + {
>>> + pcpu_schedule_unlock_irq(lock, cpu);
>>
>> I can't figure what it is that guarantees that this unlock isn't
>> going to be followed ...
>>
>>> + sched_context_switch(vprev, v, false, now);
>>> + }
>>> +
>>> + do_softirq = true;
>>> + }
>>> +
>>> if ( !prev->rendezvous_in_cnt )
>>> {
>>> pcpu_schedule_unlock_irq(lock, cpu);
>>
>> ... by another unlock here. Or wait - is sched_context_switch()
>> (and perhaps other functions involved there) lacking a "noreturn"
>> annotation?
>
> Indeed it is. Like context_switch() today. :-)
>
> I'll annotate the functions.
And now I discovered that on ARM context_switch is _not_ "noreturn".
So thanks for noticing that problem. I have fixed it in order to
avoid a latent problem in case we want to support core scheduling on
ARM some day (and yes: that would only have been a problem in core
mode).
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 35/47] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware
2019-09-27 4:42 ` Jürgen Groß
@ 2019-09-27 7:32 ` Dario Faggioli
2019-09-27 7:48 ` Jürgen Groß
0 siblings, 1 reply; 161+ messages in thread
From: Dario Faggioli @ 2019-09-27 7:32 UTC (permalink / raw)
To: Jürgen Groß, Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Julien Grall,
xen-devel, Ian Jackson
[-- Attachment #1.1: Type: text/plain, Size: 2304 bytes --]
On Fri, 2019-09-27 at 06:42 +0200, Jürgen Groß wrote:
> On 25.09.19 15:07, Jürgen Groß wrote:
> > On 24.09.19 13:55, Jan Beulich wrote:
> > > On 14.09.2019 10:52, Juergen Gross wrote:
> > > > @@ -765,16 +774,22 @@ void vcpu_wake(struct vcpu *v)
> > > > {
> > > > unsigned long flags;
> > > > spinlock_t *lock;
> > > > + struct sched_unit *unit = v->sched_unit;
> > > > TRACE_2D(TRC_SCHED_WAKE, v->domain->domain_id, v-
> > > > >vcpu_id);
> > > > - lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
> > > > + lock = unit_schedule_lock_irqsave(unit, &flags);
> > > > if ( likely(vcpu_runnable(v)) )
> > > > {
> > > > if ( v->runstate.state >= RUNSTATE_blocked )
> > > > vcpu_runstate_change(v, RUNSTATE_runnable,
> > > > NOW());
> > > > - sched_wake(vcpu_scheduler(v), v->sched_unit);
> > > > + sched_wake(vcpu_scheduler(v), unit);
> > >
> > > Is this correct / necessary when the unit is not asleep as a
> > > whole?
> > > After all the corresponding sched_sleep() further up is called
> > > conditionally only.
> >
> > Oh, indeed. Will change that.
>
> It turned out this is not so easy at it seemed.
>
> I encountered dom0 boot hangs with making the call conditional, even
> when running in cpu scheduling mode. I guess the reason is that a
> vcpu
> can call do_poll() which will try to put itself to sleep and in some
> cases call vcpu_wake() in case the condition already changed. In that
> case we need the sched_wake() call even if the unit is still running.
>
TBH, I think it is ok for this call to be unconditional. Indeed it
looks a bit weird when you compare this to the sched_sleep() calls in
vcpu_sleep_nosync_locked(), as they are conditional, but I think a
comment explaining why this has to be the case would be enough.
E.g., something like what the changelog already say, in
vcpu_sleep_nosync_locked(), and maybe something like what you said
here, in vcpu_wake().
Regards
--
Dario Faggioli, Ph.D
http://about.me/dario.faggioli
Virtualization Software Engineer
SUSE Labs, SUSE https://www.suse.com/
-------------------------------------------------------------------
<<This happens because _I_ choose it to happen!>> (Raistlin Majere)
[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
[-- Attachment #2: Type: text/plain, Size: 157 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
* Re: [Xen-devel] [PATCH v3 35/47] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware
2019-09-27 7:32 ` Dario Faggioli
@ 2019-09-27 7:48 ` Jürgen Groß
0 siblings, 0 replies; 161+ messages in thread
From: Jürgen Groß @ 2019-09-27 7:48 UTC (permalink / raw)
To: Dario Faggioli, Jan Beulich
Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk,
George Dunlap, Andrew Cooper, Tim Deegan, Julien Grall,
xen-devel, Ian Jackson
On 27.09.19 09:32, Dario Faggioli wrote:
> On Fri, 2019-09-27 at 06:42 +0200, Jürgen Groß wrote:
>> On 25.09.19 15:07, Jürgen Groß wrote:
>>> On 24.09.19 13:55, Jan Beulich wrote:
>>>> On 14.09.2019 10:52, Juergen Gross wrote:
>>>>> @@ -765,16 +774,22 @@ void vcpu_wake(struct vcpu *v)
>>>>> {
>>>>> unsigned long flags;
>>>>> spinlock_t *lock;
>>>>> + struct sched_unit *unit = v->sched_unit;
>>>>> TRACE_2D(TRC_SCHED_WAKE, v->domain->domain_id, v-
>>>>>> vcpu_id);
>>>>> - lock = unit_schedule_lock_irqsave(v->sched_unit, &flags);
>>>>> + lock = unit_schedule_lock_irqsave(unit, &flags);
>>>>> if ( likely(vcpu_runnable(v)) )
>>>>> {
>>>>> if ( v->runstate.state >= RUNSTATE_blocked )
>>>>> vcpu_runstate_change(v, RUNSTATE_runnable,
>>>>> NOW());
>>>>> - sched_wake(vcpu_scheduler(v), v->sched_unit);
>>>>> + sched_wake(vcpu_scheduler(v), unit);
>>>>
>>>> Is this correct / necessary when the unit is not asleep as a
>>>> whole?
>>>> After all the corresponding sched_sleep() further up is called
>>>> conditionally only.
>>>
>>> Oh, indeed. Will change that.
>>
>> It turned out this is not so easy at it seemed.
>>
>> I encountered dom0 boot hangs with making the call conditional, even
>> when running in cpu scheduling mode. I guess the reason is that a
>> vcpu
>> can call do_poll() which will try to put itself to sleep and in some
>> cases call vcpu_wake() in case the condition already changed. In that
>> case we need the sched_wake() call even if the unit is still running.
>>
> TBH, I think it is ok for this call to be unconditional. Indeed it
> looks a bit weird when you compare this to the sched_sleep() calls in
> vcpu_sleep_nosync_locked(), as they are conditional, but I think a
> comment explaining why this has to be the case would be enough.
>
> E.g., something like what the changelog already say, in
> vcpu_sleep_nosync_locked(), and maybe something like what you said
> here, in vcpu_wake().
Okay, will add comments.
Juergen
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 161+ messages in thread
end of thread, other threads:[~2019-09-27 7:48 UTC | newest]
Thread overview: 161+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-09-14 8:52 [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 01/47] xen/sched: use new sched_unit instead of vcpu in scheduler interfaces Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 02/47] xen/sched: move per-vcpu scheduler private data pointer to sched_unit Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 03/47] xen/sched: build a linked list of struct sched_unit Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 04/47] xen/sched: introduce struct sched_resource Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 05/47] xen/sched: let pick_cpu return a scheduler resource Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 06/47] xen/sched: switch schedule_data.curr to point at sched_unit Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 07/47] xen/sched: move per cpu scheduler private data into struct sched_resource Juergen Gross
2019-09-19 15:27 ` Jan Beulich
2019-09-24 11:41 ` Jürgen Groß
2019-09-24 12:08 ` Jan Beulich
2019-09-24 15:10 ` Jürgen Groß
2019-09-24 17:07 ` Dario Faggioli
2019-09-25 6:49 ` Jürgen Groß
2019-09-24 17:11 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 08/47] xen/sched: switch vcpu_schedule_lock to unit_schedule_lock Juergen Gross
2019-09-24 17:18 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 09/47] xen/sched: move some per-vcpu items to struct sched_unit Juergen Gross
2019-09-19 15:38 ` Jan Beulich
2019-09-24 11:44 ` Jürgen Groß
2019-09-24 17:23 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 10/47] xen/sched: add scheduler helpers hiding vcpu Juergen Gross
2019-09-19 15:45 ` Jan Beulich
2019-09-24 11:46 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 11/47] xen/sched: rename scheduler related perf counters Juergen Gross
2019-09-24 17:25 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 12/47] xen/sched: switch struct task_slice from vcpu to sched_unit Juergen Gross
2019-09-25 15:23 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 13/47] xen/sched: add is_running indicator to struct sched_unit Juergen Gross
2019-09-19 15:53 ` Jan Beulich
2019-09-24 11:47 ` Jürgen Groß
2019-09-24 12:00 ` Jan Beulich
2019-09-24 12:34 ` Jürgen Groß
2019-09-25 15:27 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 14/47] xen/sched: make null scheduler vcpu agnostic Juergen Gross
2019-09-25 12:51 ` Dario Faggioli
2019-09-25 12:59 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 15/47] xen/sched: make rt " Juergen Gross
2019-09-25 13:20 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 16/47] xen/sched: make credit " Juergen Gross
2019-09-25 14:21 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 17/47] xen/sched: make credit2 " Juergen Gross
2019-09-25 15:02 ` Dario Faggioli
2019-09-25 15:18 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 18/47] xen/sched: make arinc653 " Juergen Gross
2019-09-25 13:51 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 19/47] xen: add sched_unit_pause_nosync() and sched_unit_unpause() Juergen Gross
2019-09-25 15:20 ` Dario Faggioli
2019-09-26 4:49 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 20/47] xen: let vcpu_create() select processor Juergen Gross
2019-09-25 16:31 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 21/47] xen/sched: use sched_resource cpu instead smp_processor_id in schedulers Juergen Gross
2019-09-26 10:01 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 22/47] xen/sched: switch schedule() from vcpus to sched_units Juergen Gross
2019-09-25 16:34 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 23/47] xen/sched: switch sched_move_irqs() to take sched_unit as parameter Juergen Gross
2019-09-20 14:34 ` Jan Beulich
2019-09-24 11:55 ` Jürgen Groß
2019-09-24 20:43 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 24/47] xen: switch from for_each_vcpu() to for_each_sched_unit() Juergen Gross
2019-09-20 15:05 ` Jan Beulich
2019-09-24 12:13 ` Jürgen Groß
2019-09-24 12:31 ` Jan Beulich
2019-09-24 15:00 ` Jürgen Groß
2019-09-24 15:04 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 25/47] xen/sched: add runstate counters to struct sched_unit Juergen Gross
2019-09-20 15:27 ` Jan Beulich
2019-09-24 13:50 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 26/47] xen/sched: Change vcpu_migrate_*() to operate on schedule unit Juergen Gross
2019-09-24 22:33 ` Dario Faggioli
2019-09-25 12:04 ` Jürgen Groß
2019-09-25 16:37 ` Dario Faggioli
2019-09-26 4:51 ` Jürgen Groß
2019-09-26 13:29 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 27/47] xen/sched: move struct task_slice into struct sched_unit Juergen Gross
2019-09-26 10:30 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 28/47] xen/sched: add code to sync scheduling of all vcpus of a sched unit Juergen Gross
2019-09-20 16:08 ` Jan Beulich
2019-09-24 14:14 ` Jürgen Groß
2019-09-24 14:39 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 29/47] xen/sched: introduce unit_runnable_state() Juergen Gross
2019-09-23 15:24 ` Jan Beulich
2019-09-24 14:25 ` Jürgen Groß
2019-09-24 14:45 ` Jan Beulich
2019-09-24 14:48 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 30/47] xen/sched: add support for multiple vcpus per sched unit where missing Juergen Gross
2019-09-23 15:41 ` Jan Beulich
2019-09-24 14:41 ` Jürgen Groß
2019-09-24 15:00 ` Jan Beulich
2019-09-24 15:09 ` Jürgen Groß
2019-09-24 15:22 ` Jan Beulich
2019-09-25 12:40 ` Jürgen Groß
2019-09-25 13:07 ` Jan Beulich
2019-09-26 13:53 ` Dario Faggioli
2019-09-26 14:24 ` Jan Beulich
2019-09-26 14:40 ` Jürgen Groß
2019-09-26 16:41 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 31/47] xen/sched: modify cpupool_domain_cpumask() to be an unit mask Juergen Gross
2019-09-23 15:44 ` Jan Beulich
2019-09-24 14:45 ` Jürgen Groß
2019-09-23 15:50 ` Jan Beulich
2019-09-24 14:46 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 32/47] xen/sched: support allocating multiple vcpus into one sched unit Juergen Gross
2019-09-24 9:46 ` Jan Beulich
2019-09-24 10:06 ` Jürgen Groß
2019-09-24 10:13 ` Jan Beulich
2019-09-24 15:13 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 33/47] xen/sched: add a percpu resource index Juergen Gross
2019-09-24 10:05 ` Jan Beulich
2019-09-24 15:20 ` Jürgen Groß
2019-09-24 15:29 ` Jan Beulich
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 34/47] xen/sched: add fall back to idle vcpu when scheduling unit Juergen Gross
2019-09-24 10:53 ` Jan Beulich
2019-09-25 12:58 ` Jürgen Groß
2019-09-25 13:11 ` Jan Beulich
2019-09-25 13:15 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 35/47] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware Juergen Gross
2019-09-24 11:55 ` Jan Beulich
2019-09-25 13:07 ` Jürgen Groß
2019-09-27 4:42 ` Jürgen Groß
2019-09-27 7:32 ` Dario Faggioli
2019-09-27 7:48 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 36/47] xen/sched: carve out freeing sched_unit memory into dedicated function Juergen Gross
2019-09-24 12:04 ` Jan Beulich
2019-09-25 13:09 ` Jürgen Groß
2019-09-25 13:16 ` Jan Beulich
2019-09-25 17:31 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 37/47] xen/sched: move per-cpu variable scheduler to struct sched_resource Juergen Gross
2019-09-24 12:16 ` Jan Beulich
2019-09-25 13:13 ` Jürgen Groß
2019-09-26 9:06 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 38/47] xen/sched: move per-cpu variable cpupool " Juergen Gross
2019-09-24 13:10 ` Jan Beulich
2019-09-25 13:17 ` Jürgen Groß
2019-09-26 9:09 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 39/47] xen/sched: reject switching smt on/off with core scheduling active Juergen Gross
2019-09-26 9:10 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 40/47] xen/sched: prepare per-cpupool scheduling granularity Juergen Gross
2019-09-24 13:34 ` Jan Beulich
2019-09-25 13:31 ` Jürgen Groß
2019-09-26 9:41 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 41/47] xen/sched: split schedule_cpu_switch() Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 42/47] xen/sched: protect scheduling resource via rcu Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 43/47] xen/sched: support multiple cpus per scheduling resource Juergen Gross
2019-09-24 13:49 ` Jan Beulich
2019-09-25 13:39 ` Jürgen Groß
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 44/47] xen/sched: support differing granularity in schedule_cpu_[add/rm]() Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 45/47] xen/sched: support core scheduling for moving cpus to/from cpupools Juergen Gross
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 46/47] xen/sched: disable scheduling when entering ACPI deep sleep states Juergen Gross
2019-09-25 16:02 ` Jan Beulich
2019-09-26 9:41 ` Dario Faggioli
2019-09-14 8:52 ` [Xen-devel] [PATCH v3 47/47] xen/sched: add scheduling granularity enum Juergen Gross
2019-09-26 9:46 ` Dario Faggioli
2019-09-26 12:37 ` Jürgen Groß
2019-09-26 16:21 ` Dario Faggioli
2019-09-20 16:14 ` [Xen-devel] [PATCH v3 00/47] xen: add core scheduling support Jan Beulich
2019-09-24 10:36 ` Dario Faggioli
2019-09-24 11:15 ` Sergey Dyasli
2019-09-24 11:17 ` Jürgen Groß
2019-09-24 17:29 ` Dario Faggioli
2019-09-24 17:42 ` Igor Druzhinin
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.