From: Juergen Gross <jgross@suse.com>
To: xen-devel@lists.xenproject.org
Cc: Juergen Gross <jgross@suse.com>,
George Dunlap <george.dunlap@eu.citrix.com>,
Josh Whitehead <josh.whitehead@dornerworks.com>,
Robert VanVossen <robert.vanvossen@dornerworks.com>,
Dario Faggioli <dfaggioli@suse.com>
Subject: [Xen-devel] [PATCH v2 18/48] xen/sched: make arinc653 scheduler vcpu agnostic.
Date: Fri, 9 Aug 2019 16:58:03 +0200 [thread overview]
Message-ID: <20190809145833.1020-19-jgross@suse.com> (raw)
In-Reply-To: <20190809145833.1020-1-jgross@suse.com>
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 4136c33e2d..213bc960ef 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
@@ -611,21 +606,20 @@ a653sched_do_schedule(
static struct sched_resource *
a653sched_pick_resource(const struct scheduler *ops, 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);
}
@@ -636,18 +630,18 @@ a653sched_pick_resource(const struct scheduler *ops, struct sched_unit *unit)
* @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
next prev parent reply other threads:[~2019-08-09 14:59 UTC|newest]
Thread overview: 126+ messages / expand[flat|nested] mbox.gz Atom feed top
2019-08-09 14:57 [Xen-devel] [PATCH v2 00/48] xen: add core scheduling support Juergen Gross
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 01/48] xen/sched: use new sched_unit instead of vcpu in scheduler interfaces Juergen Gross
2019-09-02 9:07 ` Jan Beulich
2019-09-09 5:26 ` Juergen Gross
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 02/48] xen/sched: move per-vcpu scheduler private data pointer to sched_unit Juergen Gross
2019-08-23 10:47 ` Dario Faggioli
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 03/48] xen/sched: build a linked list of struct sched_unit Juergen Gross
2019-08-23 10:52 ` Dario Faggioli
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 04/48] xen/sched: introduce struct sched_resource Juergen Gross
2019-08-23 10:54 ` Dario Faggioli
2019-09-04 13:10 ` Jan Beulich
2019-09-09 5:31 ` Juergen Gross
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 05/48] xen/sched: let pick_cpu return a scheduler resource Juergen Gross
2019-09-04 13:34 ` Jan Beulich
2019-09-09 5:43 ` Juergen Gross
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 06/48] xen/sched: switch schedule_data.curr to point at sched_unit Juergen Gross
2019-09-04 13:36 ` Jan Beulich
2019-09-09 5:46 ` Juergen Gross
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 07/48] xen/sched: move per cpu scheduler private data into struct sched_resource Juergen Gross
2019-09-04 13:48 ` Jan Beulich
2019-09-05 7:13 ` Juergen Gross
2019-09-05 7:38 ` Jan Beulich
2019-09-09 13:03 ` Dario Faggioli
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 08/48] xen/sched: switch vcpu_schedule_lock to unit_schedule_lock Juergen Gross
2019-09-04 14:02 ` Jan Beulich
2019-09-04 14:41 ` Juergen Gross
2019-09-04 14:54 ` Jan Beulich
2019-09-04 15:02 ` Juergen Gross
2019-09-11 16:02 ` Dario Faggioli
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 09/48] xen/sched: move some per-vcpu items to struct sched_unit Juergen Gross
2019-09-04 14:16 ` Jan Beulich
2019-09-09 6:39 ` Juergen Gross
2019-09-09 6:55 ` Jan Beulich
2019-09-09 7:05 ` Juergen Gross
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 10/48] xen/sched: add scheduler helpers hiding vcpu Juergen Gross
2019-09-04 14:49 ` Jan Beulich
2019-09-11 13:22 ` Juergen Gross
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 11/48] xen/sched: rename scheduler related perf counters Juergen Gross
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 12/48] xen/sched: switch struct task_slice from vcpu to sched_unit Juergen Gross
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 13/48] xen/sched: add is_running indicator to struct sched_unit Juergen Gross
2019-09-04 15:06 ` Jan Beulich
2019-09-11 13:44 ` Juergen Gross
2019-09-11 15:06 ` Jan Beulich
2019-09-11 15:32 ` Juergen Gross
2019-08-09 14:57 ` [Xen-devel] [PATCH v2 14/48] xen/sched: make null scheduler vcpu agnostic Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 15/48] xen/sched: make rt " Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 16/48] xen/sched: make credit " Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 17/48] xen/sched: make credit2 " Juergen Gross
2019-08-09 14:58 ` Juergen Gross [this message]
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 19/48] xen: add sched_unit_pause_nosync() and sched_unit_unpause() Juergen Gross
2019-09-09 13:34 ` Jan Beulich
2019-09-11 14:15 ` Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 20/48] xen: let vcpu_create() select processor Juergen Gross
2019-08-23 16:42 ` Julien Grall
2019-09-09 13:38 ` Jan Beulich
2019-09-11 14:22 ` Juergen Gross
2019-09-11 17:20 ` Dario Faggioli
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 21/48] xen/sched: use sched_resource cpu instead smp_processor_id in schedulers Juergen Gross
2019-09-09 14:17 ` Jan Beulich
2019-09-12 9:34 ` Juergen Gross
2019-09-12 10:04 ` Jan Beulich
2019-09-12 11:03 ` Juergen Gross
2019-09-12 11:17 ` Juergen Gross
2019-09-12 11:46 ` Jan Beulich
2019-09-12 11:53 ` Juergen Gross
2019-09-12 12:08 ` Jan Beulich
2019-09-12 12:13 ` Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 22/48] xen/sched: switch schedule() from vcpus to sched_units Juergen Gross
2019-09-09 14:35 ` Jan Beulich
2019-09-12 13:44 ` Juergen Gross
2019-09-12 14:34 ` Jan Beulich
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 23/48] xen/sched: switch sched_move_irqs() to take sched_unit as parameter Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 24/48] xen: switch from for_each_vcpu() to for_each_sched_unit() Juergen Gross
2019-09-09 15:14 ` Jan Beulich
2019-09-12 14:02 ` Juergen Gross
2019-09-12 14:40 ` Jan Beulich
2019-09-12 14:47 ` Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 25/48] xen/sched: add runstate counters to struct sched_unit Juergen Gross
2019-09-09 14:30 ` Jan Beulich
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 26/48] xen/sched: rework and rename vcpu_force_reschedule() Juergen Gross
2019-09-10 14:06 ` Jan Beulich
2019-09-13 9:33 ` Juergen Gross
2019-09-13 9:40 ` Jan Beulich
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 27/48] xen/sched: Change vcpu_migrate_*() to operate on schedule unit Juergen Gross
2019-09-10 15:11 ` Jan Beulich
2019-09-13 12:33 ` Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 28/48] xen/sched: move struct task_slice into struct sched_unit Juergen Gross
2019-09-10 15:18 ` Jan Beulich
2019-09-13 12:56 ` Juergen Gross
2019-09-12 8:13 ` Dario Faggioli
2019-09-12 8:21 ` Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 29/48] xen/sched: add code to sync scheduling of all vcpus of a sched unit Juergen Gross
2019-09-10 15:36 ` Jan Beulich
2019-09-13 13:12 ` Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 30/48] xen/sched: introduce unit_runnable_state() Juergen Gross
2019-09-11 10:30 ` Jan Beulich
2019-09-12 10:22 ` Dario Faggioli
2019-09-13 14:07 ` Juergen Gross
2019-09-13 14:44 ` Jan Beulich
2019-09-13 15:23 ` Juergen Gross
2019-09-12 10:24 ` Dario Faggioli
2019-09-13 14:14 ` Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 31/48] xen/sched: add support for multiple vcpus per sched unit where missing Juergen Gross
2019-09-11 10:43 ` Jan Beulich
2019-09-13 15:01 ` Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 32/48] xen/sched: modify cpupool_domain_cpumask() to be an unit mask Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 33/48] xen/sched: support allocating multiple vcpus into one sched unit Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 34/48] xen/sched: add a percpu resource index Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 35/48] xen/sched: add fall back to idle vcpu when scheduling unit Juergen Gross
2019-09-11 11:33 ` Julien Grall
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 36/48] xen/sched: make vcpu_wake() and vcpu_sleep() core scheduling aware Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 37/48] xen/sched: carve out freeing sched_unit memory into dedicated function Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 38/48] xen/sched: move per-cpu variable scheduler to struct sched_resource Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 39/48] xen/sched: move per-cpu variable cpupool " Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 40/48] xen/sched: reject switching smt on/off with core scheduling active Juergen Gross
2019-09-10 15:47 ` Jan Beulich
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 41/48] xen/sched: prepare per-cpupool scheduling granularity Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 42/48] xen/sched: split schedule_cpu_switch() Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 43/48] xen/sched: protect scheduling resource via rcu Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 44/48] xen/sched: support multiple cpus per scheduling resource Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 45/48] xen/sched: support differing granularity in schedule_cpu_[add/rm]() Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 46/48] xen/sched: support core scheduling for moving cpus to/from cpupools Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 47/48] xen/sched: disable scheduling when entering ACPI deep sleep states Juergen Gross
2019-08-09 14:58 ` [Xen-devel] [PATCH v2 48/48] xen/sched: add scheduling granularity enum Juergen Gross
2019-08-15 10:17 ` [Xen-devel] [PATCH v2 00/48] xen: add core scheduling support Sergey Dyasli
2019-09-05 6:22 ` Juergen Gross
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20190809145833.1020-19-jgross@suse.com \
--to=jgross@suse.com \
--cc=dfaggioli@suse.com \
--cc=george.dunlap@eu.citrix.com \
--cc=josh.whitehead@dornerworks.com \
--cc=robert.vanvossen@dornerworks.com \
--cc=xen-devel@lists.xenproject.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).