tests/unit/test-smp-parse.c

   1 /*
   2  * SMP parsing unit-tests
   3  *
   4  * Copyright (c) 2021 Huawei Technologies Co., Ltd
   5  *
   6  * Authors:
   7  *  Yanan Wang <wangyanan55@huawei.com>
   8  *
   9  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
  10  * See the COPYING.LIB file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "qom/object.h"
  15 #include "qemu/module.h"
  16 #include "qapi/error.h"
  17
  18 #include "hw/boards.h"
  19
  20 #define T true
  21 #define F false
  22
  23 #define MIN_CPUS 1   /* set the min CPUs supported by the machine as 1 */
  24 #define MAX_CPUS 512 /* set the max CPUs supported by the machine as 512 */
  25
  26 #define SMP_MACHINE_NAME "TEST-SMP"
  27
  28 /*
  29  * Used to define the generic 3-level CPU topology hierarchy
  30  *  -sockets/cores/threads
  31  */
  32 #define SMP_CONFIG_GENERIC(ha, a, hb, b, hc, c, hd, d, he, e) \
  33         {                                                     \
  34             .has_cpus    = ha, .cpus    = a,                  \
  35             .has_sockets = hb, .sockets = b,                  \
  36             .has_cores   = hc, .cores   = c,                  \
  37             .has_threads = hd, .threads = d,                  \
  38             .has_maxcpus = he, .maxcpus = e,                  \
  39         }
  40
  41 #define CPU_TOPOLOGY_GENERIC(a, b, c, d, e)                   \
  42         {                                                     \
  43             .cpus     = a,                                    \
  44             .sockets  = b,                                    \
  45             .cores    = c,                                    \
  46             .threads  = d,                                    \
  47             .max_cpus = e,                                    \
  48         }
  49
  50 /*
  51  * Currently a 4-level topology hierarchy is supported on PC machines
  52  *  -sockets/dies/cores/threads
  53  */
  54 #define SMP_CONFIG_WITH_DIES(ha, a, hb, b, hc, c, hd, d, he, e, hf, f) \
  55         {                                                     \
  56             .has_cpus    = ha, .cpus    = a,                  \
  57             .has_sockets = hb, .sockets = b,                  \
  58             .has_dies    = hc, .dies    = c,                  \
  59             .has_cores   = hd, .cores   = d,                  \
  60             .has_threads = he, .threads = e,                  \
  61             .has_maxcpus = hf, .maxcpus = f,                  \
  62         }
  63
  64 /*
  65  * Currently a 4-level topology hierarchy is supported on ARM virt machines
  66  *  -sockets/clusters/cores/threads
  67  */
  68 #define SMP_CONFIG_WITH_CLUSTERS(ha, a, hb, b, hc, c, hd, d, he, e, hf, f) \
  69         {                                                     \
  70             .has_cpus     = ha, .cpus     = a,                \
  71             .has_sockets  = hb, .sockets  = b,                \
  72             .has_clusters = hc, .clusters = c,                \
  73             .has_cores    = hd, .cores    = d,                \
  74             .has_threads  = he, .threads  = e,                \
  75             .has_maxcpus  = hf, .maxcpus  = f,                \
  76         }
  77
  78 /**
  79  * @config - the given SMP configuration
  80  * @expect_prefer_sockets - the expected parsing result for the
  81  * valid configuration, when sockets are preferred over cores
  82  * @expect_prefer_cores - the expected parsing result for the
  83  * valid configuration, when cores are preferred over sockets
  84  * @expect_error - the expected error report when the given
  85  * configuration is invalid
  86  */
  87 typedef struct SMPTestData {
  88     SMPConfiguration config;
  89     CpuTopology expect_prefer_sockets;
  90     CpuTopology expect_prefer_cores;
  91     const char *expect_error;
  92 } SMPTestData;
  93
  94 /*
  95  * List all the possible valid sub-collections of the generic 5
  96  * topology parameters (i.e. cpus/maxcpus/sockets/cores/threads),
  97  * then test the automatic calculation algorithm of the missing
  98  * values in the parser.
  99  */
 100 static const struct SMPTestData data_generic_valid[] = {
 101     {
 102         /* config: no configuration provided
 103          * expect: cpus=1,sockets=1,cores=1,threads=1,maxcpus=1 */
 104         .config = SMP_CONFIG_GENERIC(F, 0, F, 0, F, 0, F, 0, F, 0),
 105         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(1, 1, 1, 1, 1),
 106         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(1, 1, 1, 1, 1),
 107     }, {
 108         /* config: -smp 8
 109          * prefer_sockets: cpus=8,sockets=8,cores=1,threads=1,maxcpus=8
 110          * prefer_cores: cpus=8,sockets=1,cores=8,threads=1,maxcpus=8 */
 111         .config = SMP_CONFIG_GENERIC(T, 8, F, 0, F, 0, F, 0, F, 0),
 112         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 8, 1, 1, 8),
 113         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 1, 8, 1, 8),
 114     }, {
 115         /* config: -smp sockets=2
 116          * expect: cpus=2,sockets=2,cores=1,threads=1,maxcpus=2 */
 117         .config = SMP_CONFIG_GENERIC(F, 0, T, 2, F, 0, F, 0, F, 0),
 118         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(2, 2, 1, 1, 2),
 119         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(2, 2, 1, 1, 2),
 120     }, {
 121         /* config: -smp cores=4
 122          * expect: cpus=4,sockets=1,cores=4,threads=1,maxcpus=4 */
 123         .config = SMP_CONFIG_GENERIC(F, 0, F, 0, T, 4, F, 0, F, 0),
 124         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(4, 1, 4, 1, 4),
 125         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(4, 1, 4, 1, 4),
 126     }, {
 127         /* config: -smp threads=2
 128          * expect: cpus=2,sockets=1,cores=1,threads=2,maxcpus=2 */
 129         .config = SMP_CONFIG_GENERIC(F, 0, F, 0, F, 0, T, 2, F, 0),
 130         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(2, 1, 1, 2, 2),
 131         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(2, 1, 1, 2, 2),
 132     }, {
 133         /* config: -smp maxcpus=16
 134          * prefer_sockets: cpus=16,sockets=16,cores=1,threads=1,maxcpus=16
 135          * prefer_cores: cpus=16,sockets=1,cores=16,threads=1,maxcpus=16 */
 136         .config = SMP_CONFIG_GENERIC(F, 0, F, 0, F, 0, F, 0, T, 16),
 137         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(16, 16, 1, 1, 16),
 138         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(16, 1, 16, 1, 16),
 139     }, {
 140         /* config: -smp 8,sockets=2
 141          * expect: cpus=8,sockets=2,cores=4,threads=1,maxcpus=8 */
 142         .config = SMP_CONFIG_GENERIC(T, 8, T, 2, F, 0, F, 0, F, 0),
 143         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 4, 1, 8),
 144         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 4, 1, 8),
 145     }, {
 146         /* config: -smp 8,cores=4
 147          * expect: cpus=8,sockets=2,cores=4,threads=1,maxcpus=8 */
 148         .config = SMP_CONFIG_GENERIC(T, 8, F, 0, T, 4, F, 0, F, 0),
 149         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 4, 1, 8),
 150         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 4, 1, 8),
 151     }, {
 152         /* config: -smp 8,threads=2
 153          * prefer_sockets: cpus=8,sockets=4,cores=1,threads=2,maxcpus=8
 154          * prefer_cores: cpus=8,sockets=1,cores=4,threads=2,maxcpus=8 */
 155         .config = SMP_CONFIG_GENERIC(T, 8, F, 0, F, 0, T, 2, F, 0),
 156         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 4, 1, 2, 8),
 157         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 1, 4, 2, 8),
 158     }, {
 159         /* config: -smp 8,maxcpus=16
 160          * prefer_sockets: cpus=8,sockets=16,cores=1,threads=1,maxcpus=16
 161          * prefer_cores: cpus=8,sockets=1,cores=16,threads=1,maxcpus=16 */
 162         .config = SMP_CONFIG_GENERIC(T, 8, F, 0, F, 0, F, 0, T, 16),
 163         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 16, 1, 1, 16),
 164         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 1, 16, 1, 16),
 165     }, {
 166         /* config: -smp sockets=2,cores=4
 167          * expect: cpus=8,sockets=2,cores=4,threads=1,maxcpus=8 */
 168         .config = SMP_CONFIG_GENERIC(F, 0, T, 2, T, 4, F, 0, F, 0),
 169         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 4, 1, 8),
 170         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 4, 1, 8),
 171     }, {
 172         /* config: -smp sockets=2,threads=2
 173          * expect: cpus=4,sockets=2,cores=1,threads=2,maxcpus=4 */
 174         .config = SMP_CONFIG_GENERIC(F, 0, T, 2, F, 0, T, 2, F, 0),
 175         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(4, 2, 1, 2, 4),
 176         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(4, 2, 1, 2, 4),
 177     }, {
 178         /* config: -smp sockets=2,maxcpus=16
 179          * expect: cpus=16,sockets=2,cores=8,threads=1,maxcpus=16 */
 180         .config = SMP_CONFIG_GENERIC(F, 0, T, 2, F, 0, F, 0, T, 16),
 181         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(16, 2, 8, 1, 16),
 182         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(16, 2, 8, 1, 16),
 183     }, {
 184         /* config: -smp cores=4,threads=2
 185          * expect: cpus=8,sockets=1,cores=4,threads=2,maxcpus=8 */
 186         .config = SMP_CONFIG_GENERIC(F, 0, F, 0, T, 4, T, 2, F, 0),
 187         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 1, 4, 2, 8),
 188         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 1, 4, 2, 8),
 189     }, {
 190         /* config: -smp cores=4,maxcpus=16
 191          * expect: cpus=16,sockets=4,cores=4,threads=1,maxcpus=16 */
 192         .config = SMP_CONFIG_GENERIC(F, 0, F, 0, T, 4, F, 0, T, 16),
 193         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(16, 4, 4, 1, 16),
 194         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(16, 4, 4, 1, 16),
 195     }, {
 196         /* config: -smp threads=2,maxcpus=16
 197          * prefer_sockets: cpus=16,sockets=8,cores=1,threads=2,maxcpus=16
 198          * prefer_cores: cpus=16,sockets=1,cores=8,threads=2,maxcpus=16 */
 199         .config = SMP_CONFIG_GENERIC(F, 0, F, 0, F, 0, T, 2, T, 16),
 200         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(16, 8, 1, 2, 16),
 201         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(16, 1, 8, 2, 16),
 202     }, {
 203         /* config: -smp 8,sockets=2,cores=4
 204          * expect: cpus=8,sockets=2,cores=4,threads=1,maxcpus=8 */
 205         .config = SMP_CONFIG_GENERIC(T, 8, T, 2, T, 4, F, 0, F, 0),
 206         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 4, 1, 8),
 207         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 4, 1, 8),
 208     }, {
 209         /* config: -smp 8,sockets=2,threads=2
 210          * expect: cpus=8,sockets=2,cores=2,threads=2,maxcpus=8 */
 211         .config = SMP_CONFIG_GENERIC(T, 8, T, 2, F, 0, T, 2, F, 0),
 212         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 2, 2, 8),
 213         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 2, 2, 8),
 214     }, {
 215         /* config: -smp 8,sockets=2,maxcpus=16
 216          * expect: cpus=8,sockets=2,cores=8,threads=1,maxcpus=16 */
 217         .config = SMP_CONFIG_GENERIC(T, 8, T, 2, F, 0, F, 0, T, 16),
 218         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 8, 1, 16),
 219         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 8, 1, 16),
 220     }, {
 221         /* config: -smp 8,cores=4,threads=2
 222          * expect: cpus=8,sockets=1,cores=4,threads=2,maxcpus=8 */
 223         .config = SMP_CONFIG_GENERIC(T, 8, F, 0, T, 4, T, 2, F, 0),
 224         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 1, 4, 2, 8),
 225         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 1, 4, 2, 8),
 226     }, {
 227         /* config: -smp 8,cores=4,maxcpus=16
 228          * expect: cpus=8,sockets=4,cores=4,threads=1,maxcpus=16 */
 229         .config = SMP_CONFIG_GENERIC(T, 8, F, 0, T, 4, F, 0, T, 16),
 230         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 4, 4, 1, 16),
 231         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 4, 4, 1, 16),
 232     }, {
 233         /* config: -smp 8,threads=2,maxcpus=16
 234          * prefer_sockets: cpus=8,sockets=8,cores=1,threads=2,maxcpus=16
 235          * prefer_cores: cpus=8,sockets=1,cores=8,threads=2,maxcpus=16 */
 236         .config = SMP_CONFIG_GENERIC(T, 8, F, 0, F, 0, T, 2, T, 16),
 237         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 8, 1, 2, 16),
 238         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 1, 8, 2, 16),
 239     }, {
 240         /* config: -smp sockets=2,cores=4,threads=2
 241          * expect: cpus=16,sockets=2,cores=4,threads=2,maxcpus=16 */
 242         .config = SMP_CONFIG_GENERIC(F, 0, T, 2, T, 4, T, 2, F, 0),
 243         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(16, 2, 4, 2, 16),
 244         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(16, 2, 4, 2, 16),
 245     }, {
 246         /* config: -smp sockets=2,cores=4,maxcpus=16
 247          * expect: cpus=16,sockets=2,cores=4,threads=2,maxcpus=16 */
 248         .config = SMP_CONFIG_GENERIC(F, 0, T, 2, T, 4, F, 0, T, 16),
 249         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(16, 2, 4, 2, 16),
 250         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(16, 2, 4, 2, 16),
 251     }, {
 252         /* config: -smp sockets=2,threads=2,maxcpus=16
 253          * expect: cpus=16,sockets=2,cores=4,threads=2,maxcpus=16 */
 254         .config = SMP_CONFIG_GENERIC(F, 0, T, 2, F, 0, T, 2, T, 16),
 255         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(16, 2, 4, 2, 16),
 256         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(16, 2, 4, 2, 16),
 257     }, {
 258         /* config: -smp cores=4,threads=2,maxcpus=16
 259          * expect: cpus=16,sockets=2,cores=4,threads=2,maxcpus=16 */
 260         .config = SMP_CONFIG_GENERIC(F, 0, F, 0, T, 4, T, 2, T, 16),
 261         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(16, 2, 4, 2, 16),
 262         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(16, 2, 4, 2, 16),
 263     }, {
 264         /* config: -smp 8,sockets=2,cores=4,threads=1
 265          * expect: cpus=8,sockets=2,cores=4,threads=1,maxcpus=8 */
 266         .config = SMP_CONFIG_GENERIC(T, 8, T, 2, T, 4, T, 1, F, 0),
 267         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 4, 1, 8),
 268         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 4, 1, 8),
 269     }, {
 270         /* config: -smp 8,sockets=2,cores=4,maxcpus=16
 271          * expect: cpus=8,sockets=2,cores=4,threads=2,maxcpus=16 */
 272         .config = SMP_CONFIG_GENERIC(T, 8, T, 2, T, 4, F, 0, T, 16),
 273         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 4, 2, 16),
 274         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 4, 2, 16),
 275     }, {
 276         /* config: -smp 8,sockets=2,threads=2,maxcpus=16
 277          * expect: cpus=8,sockets=2,cores=4,threads=2,maxcpus=16 */
 278         .config = SMP_CONFIG_GENERIC(T, 8, T, 2, F, 0, T, 2, T, 16),
 279         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 4, 2, 16),
 280         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 4, 2, 16),
 281     }, {
 282         /* config: -smp 8,cores=4,threads=2,maxcpus=16
 283          * expect: cpus=8,sockets=2,cores=4,threads=2,maxcpus=16 */
 284         .config = SMP_CONFIG_GENERIC(T, 8, F, 0, T, 4, T, 2, T, 16),
 285         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 4, 2, 16),
 286         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 4, 2, 16),
 287     }, {
 288         /* config: -smp sockets=2,cores=4,threads=2,maxcpus=16
 289          * expect: cpus=16,sockets=2,cores=4,threads=2,maxcpus=16 */
 290         .config = SMP_CONFIG_GENERIC(F, 0, T, 2, T, 4, T, 2, T, 16),
 291         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(16, 2, 4, 2, 16),
 292         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(16, 2, 4, 2, 16),
 293     }, {
 294         /* config: -smp 8,sockets=2,cores=4,threads=2,maxcpus=16
 295          * expect: cpus=8,sockets=2,cores=4,threads=2,maxcpus=16 */
 296         .config = SMP_CONFIG_GENERIC(T, 8, T, 2, T, 4, T, 2, T, 16),
 297         .expect_prefer_sockets = CPU_TOPOLOGY_GENERIC(8, 2, 4, 2, 16),
 298         .expect_prefer_cores   = CPU_TOPOLOGY_GENERIC(8, 2, 4, 2, 16),
 299     },
 300 };
 301
 302 static const struct SMPTestData data_generic_invalid[] = {
 303     {
 304         /* config: -smp 2,dies=2 */
 305         .config = SMP_CONFIG_WITH_DIES(T, 2, F, 0, T, 2, F, 0, F, 0, F, 0),
 306         .expect_error = "dies not supported by this machine's CPU topology",
 307     }, {
 308         /* config: -smp 2,clusters=2 */
 309         .config = SMP_CONFIG_WITH_CLUSTERS(T, 2, F, 0, T, 2, F, 0, F, 0, F, 0),
 310         .expect_error = "clusters not supported by this machine's CPU topology",
 311     }, {
 312         /* config: -smp 8,sockets=2,cores=4,threads=2,maxcpus=8 */
 313         .config = SMP_CONFIG_GENERIC(T, 8, T, 2, T, 4, T, 2, T, 8),
 314         .expect_error = "Invalid CPU topology: "
 315                         "product of the hierarchy must match maxcpus: "
 316                         "sockets (2) * cores (4) * threads (2) "
 317                         "!= maxcpus (8)",
 318     }, {
 319         /* config: -smp 18,sockets=2,cores=4,threads=2,maxcpus=16 */
 320         .config = SMP_CONFIG_GENERIC(T, 18, T, 2, T, 4, T, 2, T, 16),
 321         .expect_error = "Invalid CPU topology: "
 322                         "maxcpus must be equal to or greater than smp: "
 323                         "sockets (2) * cores (4) * threads (2) "
 324                         "== maxcpus (16) < smp_cpus (18)",
 325     }, {
 326         /* config: -smp 1
 327          * should tweak the supported min CPUs to 2 for testing */
 328         .config = SMP_CONFIG_GENERIC(T, 1, F, 0, F, 0, F, 0, F, 0),
 329         .expect_error = "Invalid SMP CPUs 1. The min CPUs supported "
 330                         "by machine '" SMP_MACHINE_NAME "' is 2",
 331     }, {
 332         /* config: -smp 512
 333          * should tweak the supported max CPUs to 511 for testing */
 334         .config = SMP_CONFIG_GENERIC(T, 512, F, 0, F, 0, F, 0, F, 0),
 335         .expect_error = "Invalid SMP CPUs 512. The max CPUs supported "
 336                         "by machine '" SMP_MACHINE_NAME "' is 511",
 337     },
 338 };
 339
 340 static const struct SMPTestData data_with_dies_invalid[] = {
 341     {
 342         /* config: -smp 16,sockets=2,dies=2,cores=4,threads=2,maxcpus=16 */
 343         .config = SMP_CONFIG_WITH_DIES(T, 16, T, 2, T, 2, T, 4, T, 2, T, 16),
 344         .expect_error = "Invalid CPU topology: "
 345                         "product of the hierarchy must match maxcpus: "
 346                         "sockets (2) * dies (2) * cores (4) * threads (2) "
 347                         "!= maxcpus (16)",
 348     }, {
 349         /* config: -smp 34,sockets=2,dies=2,cores=4,threads=2,maxcpus=32 */
 350         .config = SMP_CONFIG_WITH_DIES(T, 34, T, 2, T, 2, T, 4, T, 2, T, 32),
 351         .expect_error = "Invalid CPU topology: "
 352                         "maxcpus must be equal to or greater than smp: "
 353                         "sockets (2) * dies (2) * cores (4) * threads (2) "
 354                         "== maxcpus (32) < smp_cpus (34)",
 355     },
 356 };
 357
 358 static const struct SMPTestData data_with_clusters_invalid[] = {
 359     {
 360         /* config: -smp 16,sockets=2,clusters=2,cores=4,threads=2,maxcpus=16 */
 361         .config = SMP_CONFIG_WITH_CLUSTERS(T, 16, T, 2, T, 2, T, 4, T, 2, T, 16),
 362         .expect_error = "Invalid CPU topology: "
 363                         "product of the hierarchy must match maxcpus: "
 364                         "sockets (2) * clusters (2) * cores (4) * threads (2) "
 365                         "!= maxcpus (16)",
 366     }, {
 367         /* config: -smp 34,sockets=2,clusters=2,cores=4,threads=2,maxcpus=32 */
 368         .config = SMP_CONFIG_WITH_CLUSTERS(T, 34, T, 2, T, 2, T, 4, T, 2, T, 32),
 369         .expect_error = "Invalid CPU topology: "
 370                         "maxcpus must be equal to or greater than smp: "
 371                         "sockets (2) * clusters (2) * cores (4) * threads (2) "
 372                         "== maxcpus (32) < smp_cpus (34)",
 373     },
 374 };
 375
 376 static char *smp_config_to_string(const SMPConfiguration *config)
 377 {
 378     return g_strdup_printf(
 379         "(SMPConfiguration) {\n"
 380         "    .has_cpus     = %5s, cpus     = %" PRId64 ",\n"
 381         "    .has_sockets  = %5s, sockets  = %" PRId64 ",\n"
 382         "    .has_dies     = %5s, dies     = %" PRId64 ",\n"
 383         "    .has_clusters = %5s, clusters = %" PRId64 ",\n"
 384         "    .has_cores    = %5s, cores    = %" PRId64 ",\n"
 385         "    .has_threads  = %5s, threads  = %" PRId64 ",\n"
 386         "    .has_maxcpus  = %5s, maxcpus  = %" PRId64 ",\n"
 387         "}",
 388         config->has_cpus ? "true" : "false", config->cpus,
 389         config->has_sockets ? "true" : "false", config->sockets,
 390         config->has_dies ? "true" : "false", config->dies,
 391         config->has_clusters ? "true" : "false", config->clusters,
 392         config->has_cores ? "true" : "false", config->cores,
 393         config->has_threads ? "true" : "false", config->threads,
 394         config->has_maxcpus ? "true" : "false", config->maxcpus);
 395 }
 396
 397 static char *cpu_topology_to_string(const CpuTopology *topo)
 398 {
 399     return g_strdup_printf(
 400         "(CpuTopology) {\n"
 401         "    .cpus     = %u,\n"
 402         "    .sockets  = %u,\n"
 403         "    .dies     = %u,\n"
 404         "    .clusters = %u,\n"
 405         "    .cores    = %u,\n"
 406         "    .threads  = %u,\n"
 407         "    .max_cpus = %u,\n"
 408         "}",
 409         topo->cpus, topo->sockets, topo->dies, topo->clusters,
 410         topo->cores, topo->threads, topo->max_cpus);
 411 }
 412
 413 static void check_parse(MachineState *ms, const SMPConfiguration *config,
 414                         const CpuTopology *expect_topo, const char *expect_err,
 415                         bool is_valid)
 416 {
 417     g_autofree char *config_str = smp_config_to_string(config);
 418     g_autofree char *expect_topo_str = cpu_topology_to_string(expect_topo);
 419     g_autofree char *output_topo_str = NULL;
 420     Error *err = NULL;
 421
 422     /* call the generic parser */
 423     machine_parse_smp_config(ms, config, &err);
 424
 425     output_topo_str = cpu_topology_to_string(&ms->smp);
 426
 427     /* when the configuration is supposed to be valid */
 428     if (is_valid) {
 429         if ((err == NULL) &&
 430             (ms->smp.cpus == expect_topo->cpus) &&
 431             (ms->smp.sockets == expect_topo->sockets) &&
 432             (ms->smp.dies == expect_topo->dies) &&
 433             (ms->smp.clusters == expect_topo->clusters) &&
 434             (ms->smp.cores == expect_topo->cores) &&
 435             (ms->smp.threads == expect_topo->threads) &&
 436             (ms->smp.max_cpus == expect_topo->max_cpus)) {
 437             return;
 438         }
 439
 440         if (err != NULL) {
 441             g_printerr("Test smp_parse failed!\n"
 442                        "Input configuration: %s\n"
 443                        "Should be valid: yes\n"
 444                        "Expected topology: %s\n\n"
 445                        "Result is valid: no\n"
 446                        "Output error report: %s\n",
 447                        config_str, expect_topo_str, error_get_pretty(err));
 448             goto end;
 449         }
 450
 451         g_printerr("Test smp_parse failed!\n"
 452                    "Input configuration: %s\n"
 453                    "Should be valid: yes\n"
 454                    "Expected topology: %s\n\n"
 455                    "Result is valid: yes\n"
 456                    "Output topology: %s\n",
 457                    config_str, expect_topo_str, output_topo_str);
 458         goto end;
 459     }
 460
 461     /* when the configuration is supposed to be invalid */
 462     if (err != NULL) {
 463         if (expect_err == NULL ||
 464             g_str_equal(expect_err, error_get_pretty(err))) {
 465             error_free(err);
 466             return;
 467         }
 468
 469         g_printerr("Test smp_parse failed!\n"
 470                    "Input configuration: %s\n"
 471                    "Should be valid: no\n"
 472                    "Expected error report: %s\n\n"
 473                    "Result is valid: no\n"
 474                    "Output error report: %s\n",
 475                    config_str, expect_err, error_get_pretty(err));
 476         goto end;
 477     }
 478
 479     g_printerr("Test smp_parse failed!\n"
 480                "Input configuration: %s\n"
 481                "Should be valid: no\n"
 482                "Expected error report: %s\n\n"
 483                "Result is valid: yes\n"
 484                "Output topology: %s\n",
 485                config_str, expect_err, output_topo_str);
 486
 487 end:
 488     if (err != NULL) {
 489         error_free(err);
 490     }
 491
 492     abort();
 493 }
 494
 495 static void smp_parse_test(MachineState *ms, SMPTestData *data, bool is_valid)
 496 {
 497     MachineClass *mc = MACHINE_GET_CLASS(ms);
 498
 499     mc->smp_props.prefer_sockets = true;
 500     check_parse(ms, &data->config, &data->expect_prefer_sockets,
 501                 data->expect_error, is_valid);
 502
 503     mc->smp_props.prefer_sockets = false;
 504     check_parse(ms, &data->config, &data->expect_prefer_cores,
 505                 data->expect_error, is_valid);
 506 }
 507
 508 /* The parsed results of the unsupported parameters should be 1 */
 509 static void unsupported_params_init(const MachineClass *mc, SMPTestData *data)
 510 {
 511     if (!mc->smp_props.dies_supported) {
 512         data->expect_prefer_sockets.dies = 1;
 513         data->expect_prefer_cores.dies = 1;
 514     }
 515
 516     if (!mc->smp_props.clusters_supported) {
 517         data->expect_prefer_sockets.clusters = 1;
 518         data->expect_prefer_cores.clusters = 1;
 519     }
 520 }
 521
 522 static void machine_base_class_init(ObjectClass *oc, void *data)
 523 {
 524     MachineClass *mc = MACHINE_CLASS(oc);
 525
 526     mc->min_cpus = MIN_CPUS;
 527     mc->max_cpus = MAX_CPUS;
 528
 529     mc->name = g_strdup(SMP_MACHINE_NAME);
 530 }
 531
 532 static void machine_generic_invalid_class_init(ObjectClass *oc, void *data)
 533 {
 534     MachineClass *mc = MACHINE_CLASS(oc);
 535
 536     /* Force invalid min CPUs and max CPUs */
 537     mc->min_cpus = 2;
 538     mc->max_cpus = 511;
 539 }
 540
 541 static void machine_with_dies_class_init(ObjectClass *oc, void *data)
 542 {
 543     MachineClass *mc = MACHINE_CLASS(oc);
 544
 545     mc->smp_props.dies_supported = true;
 546 }
 547
 548 static void machine_with_clusters_class_init(ObjectClass *oc, void *data)
 549 {
 550     MachineClass *mc = MACHINE_CLASS(oc);
 551
 552     mc->smp_props.clusters_supported = true;
 553 }
 554
 555 static void test_generic_valid(const void *opaque)
 556 {
 557     const char *machine_type = opaque;
 558     Object *obj = object_new(machine_type);
 559     MachineState *ms = MACHINE(obj);
 560     MachineClass *mc = MACHINE_GET_CLASS(obj);
 561     SMPTestData data = {};
 562     int i;
 563
 564     for (i = 0; i < ARRAY_SIZE(data_generic_valid); i++) {
 565         data = data_generic_valid[i];
 566         unsupported_params_init(mc, &data);
 567
 568         smp_parse_test(ms, &data, true);
 569
 570         /* Unsupported parameters can be provided with their values as 1 */
 571         data.config.has_dies = true;
 572         data.config.dies = 1;
 573         smp_parse_test(ms, &data, true);
 574     }
 575
 576     object_unref(obj);
 577 }
 578
 579 static void test_generic_invalid(const void *opaque)
 580 {
 581     const char *machine_type = opaque;
 582     Object *obj = object_new(machine_type);
 583     MachineState *ms = MACHINE(obj);
 584     MachineClass *mc = MACHINE_GET_CLASS(obj);
 585     SMPTestData data = {};
 586     int i;
 587
 588     for (i = 0; i < ARRAY_SIZE(data_generic_invalid); i++) {
 589         data = data_generic_invalid[i];
 590         unsupported_params_init(mc, &data);
 591
 592         smp_parse_test(ms, &data, false);
 593     }
 594
 595     object_unref(obj);
 596 }
 597
 598 static void test_with_dies(const void *opaque)
 599 {
 600     const char *machine_type = opaque;
 601     Object *obj = object_new(machine_type);
 602     MachineState *ms = MACHINE(obj);
 603     MachineClass *mc = MACHINE_GET_CLASS(obj);
 604     SMPTestData data = {};
 605     unsigned int num_dies = 2;
 606     int i;
 607
 608     for (i = 0; i < ARRAY_SIZE(data_generic_valid); i++) {
 609         data = data_generic_valid[i];
 610         unsupported_params_init(mc, &data);
 611
 612         /* when dies parameter is omitted, it will be set as 1 */
 613         data.expect_prefer_sockets.dies = 1;
 614         data.expect_prefer_cores.dies = 1;
 615
 616         smp_parse_test(ms, &data, true);
 617
 618         /* when dies parameter is specified */
 619         data.config.has_dies = true;
 620         data.config.dies = num_dies;
 621         if (data.config.has_cpus) {
 622             data.config.cpus *= num_dies;
 623         }
 624         if (data.config.has_maxcpus) {
 625             data.config.maxcpus *= num_dies;
 626         }
 627
 628         data.expect_prefer_sockets.dies = num_dies;
 629         data.expect_prefer_sockets.cpus *= num_dies;
 630         data.expect_prefer_sockets.max_cpus *= num_dies;
 631         data.expect_prefer_cores.dies = num_dies;
 632         data.expect_prefer_cores.cpus *= num_dies;
 633         data.expect_prefer_cores.max_cpus *= num_dies;
 634
 635         smp_parse_test(ms, &data, true);
 636     }
 637
 638     for (i = 0; i < ARRAY_SIZE(data_with_dies_invalid); i++) {
 639         data = data_with_dies_invalid[i];
 640         unsupported_params_init(mc, &data);
 641
 642         smp_parse_test(ms, &data, false);
 643     }
 644
 645     object_unref(obj);
 646 }
 647
 648 static void test_with_clusters(const void *opaque)
 649 {
 650     const char *machine_type = opaque;
 651     Object *obj = object_new(machine_type);
 652     MachineState *ms = MACHINE(obj);
 653     MachineClass *mc = MACHINE_GET_CLASS(obj);
 654     SMPTestData data = {};
 655     unsigned int num_clusters = 2;
 656     int i;
 657
 658     for (i = 0; i < ARRAY_SIZE(data_generic_valid); i++) {
 659         data = data_generic_valid[i];
 660         unsupported_params_init(mc, &data);
 661
 662         /* when clusters parameter is omitted, it will be set as 1 */
 663         data.expect_prefer_sockets.clusters = 1;
 664         data.expect_prefer_cores.clusters = 1;
 665
 666         smp_parse_test(ms, &data, true);
 667
 668         /* when clusters parameter is specified */
 669         data.config.has_clusters = true;
 670         data.config.clusters = num_clusters;
 671         if (data.config.has_cpus) {
 672             data.config.cpus *= num_clusters;
 673         }
 674         if (data.config.has_maxcpus) {
 675             data.config.maxcpus *= num_clusters;
 676         }
 677
 678         data.expect_prefer_sockets.clusters = num_clusters;
 679         data.expect_prefer_sockets.cpus *= num_clusters;
 680         data.expect_prefer_sockets.max_cpus *= num_clusters;
 681         data.expect_prefer_cores.clusters = num_clusters;
 682         data.expect_prefer_cores.cpus *= num_clusters;
 683         data.expect_prefer_cores.max_cpus *= num_clusters;
 684
 685         smp_parse_test(ms, &data, true);
 686     }
 687
 688     for (i = 0; i < ARRAY_SIZE(data_with_clusters_invalid); i++) {
 689         data = data_with_clusters_invalid[i];
 690         unsupported_params_init(mc, &data);
 691
 692         smp_parse_test(ms, &data, false);
 693     }
 694
 695     object_unref(obj);
 696 }
 697
 698 /* Type info of the tested machine */
 699 static const TypeInfo smp_machine_types[] = {
 700     {
 701         .name           = TYPE_MACHINE,
 702         .parent         = TYPE_OBJECT,
 703         .abstract       = true,
 704         .class_init     = machine_base_class_init,
 705         .class_size     = sizeof(MachineClass),
 706         .instance_size  = sizeof(MachineState),
 707     }, {
 708         .name           = MACHINE_TYPE_NAME("smp-generic-valid"),
 709         .parent         = TYPE_MACHINE,
 710     }, {
 711         .name           = MACHINE_TYPE_NAME("smp-generic-invalid"),
 712         .parent         = TYPE_MACHINE,
 713         .class_init     = machine_generic_invalid_class_init,
 714     }, {
 715         .name           = MACHINE_TYPE_NAME("smp-with-dies"),
 716         .parent         = TYPE_MACHINE,
 717         .class_init     = machine_with_dies_class_init,
 718     }, {
 719         .name           = MACHINE_TYPE_NAME("smp-with-clusters"),
 720         .parent         = TYPE_MACHINE,
 721         .class_init     = machine_with_clusters_class_init,
 722     }
 723 };
 724
 725 DEFINE_TYPES(smp_machine_types)
 726
 727 int main(int argc, char *argv[])
 728 {
 729     module_call_init(MODULE_INIT_QOM);
 730
 731     g_test_init(&argc, &argv, NULL);
 732
 733     g_test_add_data_func("/test-smp-parse/generic/valid",
 734                          MACHINE_TYPE_NAME("smp-generic-valid"),
 735                          test_generic_valid);
 736     g_test_add_data_func("/test-smp-parse/generic/invalid",
 737                          MACHINE_TYPE_NAME("smp-generic-invalid"),
 738                          test_generic_invalid);
 739     g_test_add_data_func("/test-smp-parse/with_dies",
 740                          MACHINE_TYPE_NAME("smp-with-dies"),
 741                          test_with_dies);
 742     g_test_add_data_func("/test-smp-parse/with_clusters",
 743                          MACHINE_TYPE_NAME("smp-with-clusters"),
 744                          test_with_clusters);
 745
 746     g_test_run();
 747
 748     return 0;
 749 }