Message ID | 20210928035755.11684-12-wangyanan55@huawei.com |
---|---|
State | New |
Headers | show |
Series | machine: smp parsing fixes and improvement | expand |
On Tue, Sep 28, 2021 at 11:57:52AM +0800, Yanan Wang wrote: > Currently the only difference between smp_parse and pc_smp_parse > is the support of dies parameter and the related error reporting. > With some arch compat variables like "bool dies_supported", we can > make smp_parse generic enough for all arches and the PC specific > one can be removed. > > Making smp_parse() generic enough can reduce code duplication and > ease the code maintenance, and also allows extending the topology > with more arch specific members (e.g., clusters) in the future. > > Suggested-by: Andrew Jones <drjones@redhat.com> > Suggested-by: Daniel P. Berrange <berrange@redhat.com> > Signed-off-by: Yanan Wang <wangyanan55@huawei.com> > --- > hw/core/machine.c | 91 +++++++++++++++++++++++++++++++++++---------- > hw/i386/pc.c | 84 +---------------------------------------- > include/hw/boards.h | 9 +++++ > 3 files changed, 81 insertions(+), 103 deletions(-) Reviewed-by: Daniel P. Berrangé <berrange@redhat.com> Regards, Daniel
On 9/28/21 05:57, Yanan Wang wrote: > Currently the only difference between smp_parse and pc_smp_parse > is the support of dies parameter and the related error reporting. > With some arch compat variables like "bool dies_supported", we can > make smp_parse generic enough for all arches and the PC specific > one can be removed. > > Making smp_parse() generic enough can reduce code duplication and > ease the code maintenance, and also allows extending the topology > with more arch specific members (e.g., clusters) in the future. > > Suggested-by: Andrew Jones <drjones@redhat.com> > Suggested-by: Daniel P. Berrange <berrange@redhat.com> > Signed-off-by: Yanan Wang <wangyanan55@huawei.com> > --- > hw/core/machine.c | 91 +++++++++++++++++++++++++++++++++++---------- > hw/i386/pc.c | 84 +---------------------------------------- > include/hw/boards.h | 9 +++++ > 3 files changed, 81 insertions(+), 103 deletions(-) > +/* > + * smp_parse - Generic function used to parse the given SMP configuration > + * > + * Any missing parameter in "cpus/maxcpus/sockets/cores/threads" will be > + * automatically computed based on the provided ones. > + * > + * In the calculation of omitted sockets/cores/threads: we prefer sockets > + * over cores over threads before 6.2, while preferring cores over sockets > + * over threads since 6.2. > + * > + * In the calculation of cpus/maxcpus: When both maxcpus and cpus are omitted, > + * maxcpus will be computed from the given parameters and cpus will be set > + * equal to maxcpus. When only one of maxcpus and cpus is given then the > + * omitted one will be set to its given counterpart's value. Both maxcpus and > + * cpus may be specified, but maxcpus must be equal to or greater than cpus. > + * > + * For compatibility, apart from the parameters that will be computed, newly > + * introduced topology members which are likely to be target specific should > + * be directly set as 1 if they are omitted (e.g. dies for PC since 4.1). > + */ > static void smp_parse(MachineState *ms, SMPConfiguration *config, Error **errp) Can we have it return a boolean instead?
On Tue, Sep 28, 2021 at 12:57:21PM +0200, Philippe Mathieu-Daudé wrote: > On 9/28/21 05:57, Yanan Wang wrote: > > Currently the only difference between smp_parse and pc_smp_parse > > is the support of dies parameter and the related error reporting. > > With some arch compat variables like "bool dies_supported", we can > > make smp_parse generic enough for all arches and the PC specific > > one can be removed. > > > > Making smp_parse() generic enough can reduce code duplication and > > ease the code maintenance, and also allows extending the topology > > with more arch specific members (e.g., clusters) in the future. > > > > Suggested-by: Andrew Jones <drjones@redhat.com> > > Suggested-by: Daniel P. Berrange <berrange@redhat.com> > > Signed-off-by: Yanan Wang <wangyanan55@huawei.com> > > --- > > hw/core/machine.c | 91 +++++++++++++++++++++++++++++++++++---------- > > hw/i386/pc.c | 84 +---------------------------------------- > > include/hw/boards.h | 9 +++++ > > 3 files changed, 81 insertions(+), 103 deletions(-) > > > +/* > > + * smp_parse - Generic function used to parse the given SMP configuration > > + * > > + * Any missing parameter in "cpus/maxcpus/sockets/cores/threads" will be > > + * automatically computed based on the provided ones. > > + * > > + * In the calculation of omitted sockets/cores/threads: we prefer sockets > > + * over cores over threads before 6.2, while preferring cores over sockets > > + * over threads since 6.2. > > + * > > + * In the calculation of cpus/maxcpus: When both maxcpus and cpus are omitted, > > + * maxcpus will be computed from the given parameters and cpus will be set > > + * equal to maxcpus. When only one of maxcpus and cpus is given then the > > + * omitted one will be set to its given counterpart's value. Both maxcpus and > > + * cpus may be specified, but maxcpus must be equal to or greater than cpus. > > + * > > + * For compatibility, apart from the parameters that will be computed, newly > > + * introduced topology members which are likely to be target specific should > > + * be directly set as 1 if they are omitted (e.g. dies for PC since 4.1). > > + */ > > static void smp_parse(MachineState *ms, SMPConfiguration *config, Error **errp) > > Can we have it return a boolean instead? That's unrelated to this change, so ought to be a separate commit if done. Regards, Daniel
On 9/28/21 12:58, Daniel P. Berrangé wrote: > On Tue, Sep 28, 2021 at 12:57:21PM +0200, Philippe Mathieu-Daudé wrote: >> On 9/28/21 05:57, Yanan Wang wrote: >>> Currently the only difference between smp_parse and pc_smp_parse >>> is the support of dies parameter and the related error reporting. >>> With some arch compat variables like "bool dies_supported", we can >>> make smp_parse generic enough for all arches and the PC specific >>> one can be removed. >>> >>> Making smp_parse() generic enough can reduce code duplication and >>> ease the code maintenance, and also allows extending the topology >>> with more arch specific members (e.g., clusters) in the future. >>> >>> Suggested-by: Andrew Jones <drjones@redhat.com> >>> Suggested-by: Daniel P. Berrange <berrange@redhat.com> >>> Signed-off-by: Yanan Wang <wangyanan55@huawei.com> >>> --- >>> hw/core/machine.c | 91 +++++++++++++++++++++++++++++++++++---------- >>> hw/i386/pc.c | 84 +---------------------------------------- >>> include/hw/boards.h | 9 +++++ >>> 3 files changed, 81 insertions(+), 103 deletions(-) >> >>> +/* >>> + * smp_parse - Generic function used to parse the given SMP configuration >>> + * >>> + * Any missing parameter in "cpus/maxcpus/sockets/cores/threads" will be >>> + * automatically computed based on the provided ones. >>> + * >>> + * In the calculation of omitted sockets/cores/threads: we prefer sockets >>> + * over cores over threads before 6.2, while preferring cores over sockets >>> + * over threads since 6.2. >>> + * >>> + * In the calculation of cpus/maxcpus: When both maxcpus and cpus are omitted, >>> + * maxcpus will be computed from the given parameters and cpus will be set >>> + * equal to maxcpus. When only one of maxcpus and cpus is given then the >>> + * omitted one will be set to its given counterpart's value. Both maxcpus and >>> + * cpus may be specified, but maxcpus must be equal to or greater than cpus. >>> + * >>> + * For compatibility, apart from the parameters that will be computed, newly >>> + * introduced topology members which are likely to be target specific should >>> + * be directly set as 1 if they are omitted (e.g. dies for PC since 4.1). >>> + */ >>> static void smp_parse(MachineState *ms, SMPConfiguration *config, Error **errp) >> >> Can we have it return a boolean instead? > > That's unrelated to this change, so ought to be a separate commit if > done. Sure, fine by me.
On 2021/9/28 18:58, Daniel P. Berrangé wrote: > On Tue, Sep 28, 2021 at 12:57:21PM +0200, Philippe Mathieu-Daudé wrote: >> On 9/28/21 05:57, Yanan Wang wrote: >>> Currently the only difference between smp_parse and pc_smp_parse >>> is the support of dies parameter and the related error reporting. >>> With some arch compat variables like "bool dies_supported", we can >>> make smp_parse generic enough for all arches and the PC specific >>> one can be removed. >>> >>> Making smp_parse() generic enough can reduce code duplication and >>> ease the code maintenance, and also allows extending the topology >>> with more arch specific members (e.g., clusters) in the future. >>> >>> Suggested-by: Andrew Jones <drjones@redhat.com> >>> Suggested-by: Daniel P. Berrange <berrange@redhat.com> >>> Signed-off-by: Yanan Wang <wangyanan55@huawei.com> >>> --- >>> hw/core/machine.c | 91 +++++++++++++++++++++++++++++++++++---------- >>> hw/i386/pc.c | 84 +---------------------------------------- >>> include/hw/boards.h | 9 +++++ >>> 3 files changed, 81 insertions(+), 103 deletions(-) >>> +/* >>> + * smp_parse - Generic function used to parse the given SMP configuration >>> + * >>> + * Any missing parameter in "cpus/maxcpus/sockets/cores/threads" will be >>> + * automatically computed based on the provided ones. >>> + * >>> + * In the calculation of omitted sockets/cores/threads: we prefer sockets >>> + * over cores over threads before 6.2, while preferring cores over sockets >>> + * over threads since 6.2. >>> + * >>> + * In the calculation of cpus/maxcpus: When both maxcpus and cpus are omitted, >>> + * maxcpus will be computed from the given parameters and cpus will be set >>> + * equal to maxcpus. When only one of maxcpus and cpus is given then the >>> + * omitted one will be set to its given counterpart's value. Both maxcpus and >>> + * cpus may be specified, but maxcpus must be equal to or greater than cpus. >>> + * >>> + * For compatibility, apart from the parameters that will be computed, newly >>> + * introduced topology members which are likely to be target specific should >>> + * be directly set as 1 if they are omitted (e.g. dies for PC since 4.1). >>> + */ >>> static void smp_parse(MachineState *ms, SMPConfiguration *config, Error **errp) >> Can we have it return a boolean instead? > That's unrelated to this change, so ought to be a separate commit if > done. > I agree. I vaguely remember that there was a discussion about this before with Paolo. But anyway, I think the suggested change can be in a separate commit if necessary. :) Thanks, Yanan
Philippe Mathieu-Daudé <philmd@redhat.com> writes: > On 9/28/21 05:57, Yanan Wang wrote: >> Currently the only difference between smp_parse and pc_smp_parse >> is the support of dies parameter and the related error reporting. >> With some arch compat variables like "bool dies_supported", we can >> make smp_parse generic enough for all arches and the PC specific >> one can be removed. >> >> Making smp_parse() generic enough can reduce code duplication and >> ease the code maintenance, and also allows extending the topology >> with more arch specific members (e.g., clusters) in the future. >> >> Suggested-by: Andrew Jones <drjones@redhat.com> >> Suggested-by: Daniel P. Berrange <berrange@redhat.com> >> Signed-off-by: Yanan Wang <wangyanan55@huawei.com> >> --- >> hw/core/machine.c | 91 +++++++++++++++++++++++++++++++++++---------- >> hw/i386/pc.c | 84 +---------------------------------------- >> include/hw/boards.h | 9 +++++ >> 3 files changed, 81 insertions(+), 103 deletions(-) > >> +/* >> + * smp_parse - Generic function used to parse the given SMP configuration >> + * >> + * Any missing parameter in "cpus/maxcpus/sockets/cores/threads" will be >> + * automatically computed based on the provided ones. >> + * >> + * In the calculation of omitted sockets/cores/threads: we prefer sockets >> + * over cores over threads before 6.2, while preferring cores over sockets >> + * over threads since 6.2. >> + * >> + * In the calculation of cpus/maxcpus: When both maxcpus and cpus are omitted, >> + * maxcpus will be computed from the given parameters and cpus will be set >> + * equal to maxcpus. When only one of maxcpus and cpus is given then the >> + * omitted one will be set to its given counterpart's value. Both maxcpus and >> + * cpus may be specified, but maxcpus must be equal to or greater than cpus. >> + * >> + * For compatibility, apart from the parameters that will be computed, newly >> + * introduced topology members which are likely to be target specific should >> + * be directly set as 1 if they are omitted (e.g. dies for PC since 4.1). >> + */ >> static void smp_parse(MachineState *ms, SMPConfiguration *config, Error **errp) > > Can we have it return a boolean instead? Yes, please. From error.h's big comment: * = Rules = [...] * - Whenever practical, also return a value that indicates success / * failure. This can make the error checking more concise, and can * avoid useless error object creation and destruction. Note that * we still have many functions returning void. We recommend * • bool-valued functions return true on success / false on failure, * • pointer-valued functions return non-null / null pointer, and * • integer-valued functions return non-negative / negative.
On 2021/9/28 20:25, Markus Armbruster wrote: > Philippe Mathieu-Daudé <philmd@redhat.com> writes: > >> On 9/28/21 05:57, Yanan Wang wrote: >>> Currently the only difference between smp_parse and pc_smp_parse >>> is the support of dies parameter and the related error reporting. >>> With some arch compat variables like "bool dies_supported", we can >>> make smp_parse generic enough for all arches and the PC specific >>> one can be removed. >>> >>> Making smp_parse() generic enough can reduce code duplication and >>> ease the code maintenance, and also allows extending the topology >>> with more arch specific members (e.g., clusters) in the future. >>> >>> Suggested-by: Andrew Jones <drjones@redhat.com> >>> Suggested-by: Daniel P. Berrange <berrange@redhat.com> >>> Signed-off-by: Yanan Wang <wangyanan55@huawei.com> >>> --- >>> hw/core/machine.c | 91 +++++++++++++++++++++++++++++++++++---------- >>> hw/i386/pc.c | 84 +---------------------------------------- >>> include/hw/boards.h | 9 +++++ >>> 3 files changed, 81 insertions(+), 103 deletions(-) >>> +/* >>> + * smp_parse - Generic function used to parse the given SMP configuration >>> + * >>> + * Any missing parameter in "cpus/maxcpus/sockets/cores/threads" will be >>> + * automatically computed based on the provided ones. >>> + * >>> + * In the calculation of omitted sockets/cores/threads: we prefer sockets >>> + * over cores over threads before 6.2, while preferring cores over sockets >>> + * over threads since 6.2. >>> + * >>> + * In the calculation of cpus/maxcpus: When both maxcpus and cpus are omitted, >>> + * maxcpus will be computed from the given parameters and cpus will be set >>> + * equal to maxcpus. When only one of maxcpus and cpus is given then the >>> + * omitted one will be set to its given counterpart's value. Both maxcpus and >>> + * cpus may be specified, but maxcpus must be equal to or greater than cpus. >>> + * >>> + * For compatibility, apart from the parameters that will be computed, newly >>> + * introduced topology members which are likely to be target specific should >>> + * be directly set as 1 if they are omitted (e.g. dies for PC since 4.1). >>> + */ >>> static void smp_parse(MachineState *ms, SMPConfiguration *config, Error **errp) >> Can we have it return a boolean instead? > Yes, please. From error.h's big comment: > > * = Rules = > [...] > * - Whenever practical, also return a value that indicates success / > * failure. This can make the error checking more concise, and can > * avoid useless error object creation and destruction. Note that > * we still have many functions returning void. We recommend > * • bool-valued functions return true on success / false on failure, > * • pointer-valued functions return non-null / null pointer, and > * • integer-valued functions return non-negative / negative. Ok. I will add an extra patch to this series to do the change and respin. In practice the boolean return value will also make a smp parsing unit test more concise. (I'm planning to introduce one test). Thanks, Yanan
diff --git a/hw/core/machine.c b/hw/core/machine.c index a21fcd7700..f5dadcbd78 100644 --- a/hw/core/machine.c +++ b/hw/core/machine.c @@ -746,20 +746,69 @@ void machine_set_cpu_numa_node(MachineState *machine, } } +/* + * Report information of a machine's supported CPU topology hierarchy. + * Topology members will be ordered from the largest to the smallest + * in the string. + */ +static char *cpu_hierarchy_to_string(MachineState *ms) +{ + MachineClass *mc = MACHINE_GET_CLASS(ms); + GString *s = g_string_new(NULL); + + g_string_append_printf(s, "sockets (%u)", ms->smp.sockets); + + if (mc->smp_props.dies_supported) { + g_string_append_printf(s, " * dies (%u)", ms->smp.dies); + } + + g_string_append_printf(s, " * cores (%u)", ms->smp.cores); + g_string_append_printf(s, " * threads (%u)", ms->smp.threads); + + return g_string_free(s, false); +} + +/* + * smp_parse - Generic function used to parse the given SMP configuration + * + * Any missing parameter in "cpus/maxcpus/sockets/cores/threads" will be + * automatically computed based on the provided ones. + * + * In the calculation of omitted sockets/cores/threads: we prefer sockets + * over cores over threads before 6.2, while preferring cores over sockets + * over threads since 6.2. + * + * In the calculation of cpus/maxcpus: When both maxcpus and cpus are omitted, + * maxcpus will be computed from the given parameters and cpus will be set + * equal to maxcpus. When only one of maxcpus and cpus is given then the + * omitted one will be set to its given counterpart's value. Both maxcpus and + * cpus may be specified, but maxcpus must be equal to or greater than cpus. + * + * For compatibility, apart from the parameters that will be computed, newly + * introduced topology members which are likely to be target specific should + * be directly set as 1 if they are omitted (e.g. dies for PC since 4.1). + */ static void smp_parse(MachineState *ms, SMPConfiguration *config, Error **errp) { MachineClass *mc = MACHINE_GET_CLASS(ms); unsigned cpus = config->has_cpus ? config->cpus : 0; unsigned sockets = config->has_sockets ? config->sockets : 0; + unsigned dies = config->has_dies ? config->dies : 0; unsigned cores = config->has_cores ? config->cores : 0; unsigned threads = config->has_threads ? config->threads : 0; unsigned maxcpus = config->has_maxcpus ? config->maxcpus : 0; - if (config->has_dies && config->dies > 1) { + /* + * If not supported by the machine, a topology parameter must be + * omitted or specified equal to 1. + */ + if (!mc->smp_props.dies_supported && dies > 1) { error_setg(errp, "dies not supported by this machine's CPU topology"); return; } + dies = dies > 0 ? dies : 1; + /* compute missing values based on the provided ones */ if (cpus == 0 && maxcpus == 0) { sockets = sockets > 0 ? sockets : 1; @@ -773,55 +822,57 @@ static void smp_parse(MachineState *ms, SMPConfiguration *config, Error **errp) if (sockets == 0) { cores = cores > 0 ? cores : 1; threads = threads > 0 ? threads : 1; - sockets = maxcpus / (cores * threads); + sockets = maxcpus / (dies * cores * threads); } else if (cores == 0) { threads = threads > 0 ? threads : 1; - cores = maxcpus / (sockets * threads); + cores = maxcpus / (sockets * dies * threads); } } else { /* prefer cores over sockets since 6.2 */ if (cores == 0) { sockets = sockets > 0 ? sockets : 1; threads = threads > 0 ? threads : 1; - cores = maxcpus / (sockets * threads); + cores = maxcpus / (sockets * dies * threads); } else if (sockets == 0) { threads = threads > 0 ? threads : 1; - sockets = maxcpus / (cores * threads); + sockets = maxcpus / (dies * cores * threads); } } /* try to calculate omitted threads at last */ if (threads == 0) { - threads = maxcpus / (sockets * cores); + threads = maxcpus / (sockets * dies * cores); } } - maxcpus = maxcpus > 0 ? maxcpus : sockets * cores * threads; + maxcpus = maxcpus > 0 ? maxcpus : sockets * dies * cores * threads; cpus = cpus > 0 ? cpus : maxcpus; - if (sockets * cores * threads != maxcpus) { + ms->smp.cpus = cpus; + ms->smp.sockets = sockets; + ms->smp.dies = dies; + ms->smp.cores = cores; + ms->smp.threads = threads; + ms->smp.max_cpus = maxcpus; + + /* sanity-check of the computed topology */ + if (sockets * dies * cores * threads != maxcpus) { + g_autofree char *topo_msg = cpu_hierarchy_to_string(ms); error_setg(errp, "Invalid CPU topology: " "product of the hierarchy must match maxcpus: " - "sockets (%u) * cores (%u) * threads (%u) " - "!= maxcpus (%u)", - sockets, cores, threads, maxcpus); + "%s != maxcpus (%u)", + topo_msg, maxcpus); return; } if (maxcpus < cpus) { + g_autofree char *topo_msg = cpu_hierarchy_to_string(ms); error_setg(errp, "Invalid CPU topology: " "maxcpus must be equal to or greater than smp: " - "sockets (%u) * cores (%u) * threads (%u) " - "== maxcpus (%u) < smp_cpus (%u)", - sockets, cores, threads, maxcpus, cpus); + "%s == maxcpus (%u) < smp_cpus (%u)", + topo_msg, maxcpus, cpus); return; } - - ms->smp.cpus = cpus; - ms->smp.sockets = sockets; - ms->smp.cores = cores; - ms->smp.threads = threads; - ms->smp.max_cpus = maxcpus; } static void machine_get_smp(Object *obj, Visitor *v, const char *name, diff --git a/hw/i386/pc.c b/hw/i386/pc.c index 447114e57a..468fe8e0fb 100644 --- a/hw/i386/pc.c +++ b/hw/i386/pc.c @@ -710,88 +710,6 @@ void pc_acpi_smi_interrupt(void *opaque, int irq, int level) } } -/* - * This function is very similar to smp_parse() - * in hw/core/machine.c but includes CPU die support. - */ -static void pc_smp_parse(MachineState *ms, SMPConfiguration *config, Error **errp) -{ - MachineClass *mc = MACHINE_GET_CLASS(ms); - unsigned cpus = config->has_cpus ? config->cpus : 0; - unsigned sockets = config->has_sockets ? config->sockets : 0; - unsigned dies = config->has_dies ? config->dies : 0; - unsigned cores = config->has_cores ? config->cores : 0; - unsigned threads = config->has_threads ? config->threads : 0; - unsigned maxcpus = config->has_maxcpus ? config->maxcpus : 0; - - /* directly default dies to 1 if it's omitted */ - dies = dies > 0 ? dies : 1; - - /* compute missing values based on the provided ones */ - if (cpus == 0 && maxcpus == 0) { - sockets = sockets > 0 ? sockets : 1; - cores = cores > 0 ? cores : 1; - threads = threads > 0 ? threads : 1; - } else { - maxcpus = maxcpus > 0 ? maxcpus : cpus; - - if (mc->smp_prefer_sockets) { - /* prefer sockets over cores before 6.2 */ - if (sockets == 0) { - cores = cores > 0 ? cores : 1; - threads = threads > 0 ? threads : 1; - sockets = maxcpus / (dies * cores * threads); - } else if (cores == 0) { - threads = threads > 0 ? threads : 1; - cores = maxcpus / (sockets * dies * threads); - } - } else { - /* prefer cores over sockets since 6.2 */ - if (cores == 0) { - sockets = sockets > 0 ? sockets : 1; - threads = threads > 0 ? threads : 1; - cores = maxcpus / (sockets * dies * threads); - } else if (sockets == 0) { - threads = threads > 0 ? threads : 1; - sockets = maxcpus / (dies * cores * threads); - } - } - - /* try to calculate omitted threads at last */ - if (threads == 0) { - threads = maxcpus / (sockets * dies * cores); - } - } - - maxcpus = maxcpus > 0 ? maxcpus : sockets * dies * cores * threads; - cpus = cpus > 0 ? cpus : maxcpus; - - if (sockets * dies * cores * threads != maxcpus) { - error_setg(errp, "Invalid CPU topology: " - "product of the hierarchy must match maxcpus: " - "sockets (%u) * dies (%u) * cores (%u) * threads (%u) " - "!= maxcpus (%u)", - sockets, dies, cores, threads, maxcpus); - return; - } - - if (maxcpus < cpus) { - error_setg(errp, "Invalid CPU topology: " - "maxcpus must be equal to or greater than smp: " - "sockets (%u) * dies (%u) * cores (%u) * threads (%u) " - "== maxcpus (%u) < smp_cpus (%u)", - sockets, dies, cores, threads, maxcpus, cpus); - return; - } - - ms->smp.cpus = cpus; - ms->smp.sockets = sockets; - ms->smp.dies = dies; - ms->smp.cores = cores; - ms->smp.threads = threads; - ms->smp.max_cpus = maxcpus; -} - static void pc_machine_done(Notifier *notifier, void *data) { @@ -1742,7 +1660,6 @@ static void pc_machine_class_init(ObjectClass *oc, void *data) mc->auto_enable_numa_with_memdev = true; mc->has_hotpluggable_cpus = true; mc->default_boot_order = "cad"; - mc->smp_parse = pc_smp_parse; mc->block_default_type = IF_IDE; mc->max_cpus = 255; mc->reset = pc_machine_reset; @@ -1753,6 +1670,7 @@ static void pc_machine_class_init(ObjectClass *oc, void *data) hc->unplug = pc_machine_device_unplug_cb; mc->default_cpu_type = TARGET_DEFAULT_CPU_TYPE; mc->nvdimm_supported = true; + mc->smp_props.dies_supported = true; mc->default_ram_id = "pc.ram"; object_class_property_add(oc, PC_MACHINE_MAX_RAM_BELOW_4G, "size", diff --git a/include/hw/boards.h b/include/hw/boards.h index 2a1bba86c0..72a23e4e0f 100644 --- a/include/hw/boards.h +++ b/include/hw/boards.h @@ -108,6 +108,14 @@ typedef struct { CPUArchId cpus[]; } CPUArchIdList; +/** + * SMPCompatProps: + * @dies_supported - whether dies are supported by the machine + */ +typedef struct { + bool dies_supported; +} SMPCompatProps; + /** * MachineClass: * @deprecation_reason: If set, the machine is marked as deprecated. The @@ -248,6 +256,7 @@ struct MachineClass { bool numa_mem_supported; bool auto_enable_numa; bool smp_prefer_sockets; + SMPCompatProps smp_props; const char *default_ram_id; HotplugHandler *(*get_hotplug_handler)(MachineState *machine,
Currently the only difference between smp_parse and pc_smp_parse is the support of dies parameter and the related error reporting. With some arch compat variables like "bool dies_supported", we can make smp_parse generic enough for all arches and the PC specific one can be removed. Making smp_parse() generic enough can reduce code duplication and ease the code maintenance, and also allows extending the topology with more arch specific members (e.g., clusters) in the future. Suggested-by: Andrew Jones <drjones@redhat.com> Suggested-by: Daniel P. Berrange <berrange@redhat.com> Signed-off-by: Yanan Wang <wangyanan55@huawei.com> --- hw/core/machine.c | 91 +++++++++++++++++++++++++++++++++++---------- hw/i386/pc.c | 84 +---------------------------------------- include/hw/boards.h | 9 +++++ 3 files changed, 81 insertions(+), 103 deletions(-)