Commit d65af288 authored by Like Xu's avatar Like Xu Committed by Eduardo Habkost
Browse files

i386: Update new x86_apicid parsing rules with die_offset support 



In new sockets/dies/cores/threads model, the apicid of logical cpu could
imply die level info of guest cpu topology thus x86_apicid_from_cpu_idx()
need to be refactored with #dies value, so does apicid_*_offset().

To keep semantic compatibility, the legacy pkg_offset which helps to
generate CPUIDs such as 0x3 for L3 cache should be mapping to die_offset.

Signed-off-by: default avatarLike Xu <like.xu@linux.intel.com>
Message-Id: <20190612084104.34984-5-like.xu@linux.intel.com>
[ehabkost: squash unit test patch]
Message-Id: <20190612084104.34984-6-like.xu@linux.intel.com>
Reviewed-by: default avatarEduardo Habkost <ehabkost@redhat.com>
Signed-off-by: default avatarEduardo Habkost <ehabkost@redhat.com>
parent 176d2cda

hw/i386/pc.c

+17 −10
Original line number Diff line number Diff line
@@ -930,7 +930,7 @@ static uint32_t x86_cpu_apic_id_from_index(PCMachineState *pcms, 
    uint32_t correct_id;

    static bool warned;



    correct_id = x86_apicid_from_cpu_idx(ms->smp.cores,

    correct_id = x86_apicid_from_cpu_idx(pcms->smp_dies, ms->smp.cores,

                                         ms->smp.threads, cpu_index);

    if (pcmc->compat_apic_id_mode) {

        if (cpu_index != correct_id && !warned && !qtest_enabled()) {
@@ -2350,18 +2350,21 @@ static void pc_cpu_pre_plug(HotplugHandler *hotplug_dev, 
        topo.die_id = cpu->die_id;

        topo.core_id = cpu->core_id;

        topo.smt_id = cpu->thread_id;

        cpu->apic_id = apicid_from_topo_ids(smp_cores, smp_threads, &topo);

        cpu->apic_id = apicid_from_topo_ids(pcms->smp_dies, smp_cores,

                                            smp_threads, &topo);

    }



    cpu_slot = pc_find_cpu_slot(MACHINE(pcms), cpu->apic_id, &idx);

    if (!cpu_slot) {

        MachineState *ms = MACHINE(pcms);



        x86_topo_ids_from_apicid(cpu->apic_id, smp_cores, smp_threads, &topo);

        error_setg(errp, "Invalid CPU [socket: %u, core: %u, thread: %u] with"

        x86_topo_ids_from_apicid(cpu->apic_id, pcms->smp_dies,

                                 smp_cores, smp_threads, &topo);

        error_setg(errp,

            "Invalid CPU [socket: %u, die: %u, core: %u, thread: %u] with"

            " APIC ID %" PRIu32 ", valid index range 0:%d",

                   topo.pkg_id, topo.core_id, topo.smt_id, cpu->apic_id,

                   ms->possible_cpus->len - 1);

            topo.pkg_id, topo.die_id, topo.core_id, topo.smt_id,

            cpu->apic_id, ms->possible_cpus->len - 1);

        return;

    }
@@ -2377,7 +2380,8 @@ static void pc_cpu_pre_plug(HotplugHandler *hotplug_dev, 
    /* TODO: move socket_id/core_id/thread_id checks into x86_cpu_realizefn()

     * once -smp refactoring is complete and there will be CPU private

     * CPUState::nr_cores and CPUState::nr_threads fields instead of globals */

    x86_topo_ids_from_apicid(cpu->apic_id, smp_cores, smp_threads, &topo);

    x86_topo_ids_from_apicid(cpu->apic_id, pcms->smp_dies,

                             smp_cores, smp_threads, &topo);

    if (cpu->socket_id != -1 && cpu->socket_id != topo.pkg_id) {

        error_setg(errp, "property socket-id: %u doesn't match set apic-id:"

            " 0x%x (socket-id: %u)", cpu->socket_id, cpu->apic_id, topo.pkg_id);
@@ -2743,10 +2747,12 @@ pc_cpu_index_to_props(MachineState *ms, unsigned cpu_index) 
static int64_t pc_get_default_cpu_node_id(const MachineState *ms, int idx)

{

   X86CPUTopoInfo topo;

   PCMachineState *pcms = PC_MACHINE(ms);



   assert(idx < ms->possible_cpus->len);

   x86_topo_ids_from_apicid(ms->possible_cpus->cpus[idx].arch_id,

                            ms->smp.cores, ms->smp.threads, &topo);

                            pcms->smp_dies, ms->smp.cores,

                            ms->smp.threads, &topo);

   return topo.pkg_id % nb_numa_nodes;

}
@@ -2775,7 +2781,8 @@ static const CPUArchIdList *pc_possible_cpu_arch_ids(MachineState *ms) 
        ms->possible_cpus->cpus[i].vcpus_count = 1;

        ms->possible_cpus->cpus[i].arch_id = x86_cpu_apic_id_from_index(pcms, i);

        x86_topo_ids_from_apicid(ms->possible_cpus->cpus[i].arch_id,

                                 ms->smp.cores, ms->smp.threads, &topo);

                                 pcms->smp_dies, ms->smp.cores,

                                 ms->smp.threads, &topo);

        ms->possible_cpus->cpus[i].props.has_socket_id = true;

        ms->possible_cpus->cpus[i].props.socket_id = topo.pkg_id;

        ms->possible_cpus->cpus[i].props.has_die_id = true;

include/hw/i386/topology.h

+54 −22
Original line number Diff line number Diff line
@@ -63,88 +63,120 @@ static unsigned apicid_bitwidth_for_count(unsigned count) 


/* Bit width of the SMT_ID (thread ID) field on the APIC ID

 */

static inline unsigned apicid_smt_width(unsigned nr_cores, unsigned nr_threads)

static inline unsigned apicid_smt_width(unsigned nr_dies,

                                        unsigned nr_cores,

                                        unsigned nr_threads)

{

    return apicid_bitwidth_for_count(nr_threads);

}



/* Bit width of the Core_ID field

 */

static inline unsigned apicid_core_width(unsigned nr_cores, unsigned nr_threads)

static inline unsigned apicid_core_width(unsigned nr_dies,

                                         unsigned nr_cores,

                                         unsigned nr_threads)

{

    return apicid_bitwidth_for_count(nr_cores);

}



/* Bit width of the Die_ID field */

static inline unsigned apicid_die_width(unsigned nr_dies,

                                        unsigned nr_cores,

                                        unsigned nr_threads)

{

    return apicid_bitwidth_for_count(nr_dies);

}



/* Bit offset of the Core_ID field

 */

static inline unsigned apicid_core_offset(unsigned nr_cores,

static inline unsigned apicid_core_offset(unsigned nr_dies,

                                          unsigned nr_cores,

                                          unsigned nr_threads)

{

    return apicid_smt_width(nr_cores, nr_threads);

    return apicid_smt_width(nr_dies, nr_cores, nr_threads);

}



/* Bit offset of the Die_ID field */

static inline unsigned apicid_die_offset(unsigned nr_dies,

                                          unsigned nr_cores,

                                           unsigned nr_threads)

{

    return apicid_core_offset(nr_dies, nr_cores, nr_threads) +

           apicid_core_width(nr_dies, nr_cores, nr_threads);

}



/* Bit offset of the Pkg_ID (socket ID) field

 */

static inline unsigned apicid_pkg_offset(unsigned nr_cores, unsigned nr_threads)

static inline unsigned apicid_pkg_offset(unsigned nr_dies,

                                         unsigned nr_cores,

                                         unsigned nr_threads)

{

    return apicid_core_offset(nr_cores, nr_threads) +

           apicid_core_width(nr_cores, nr_threads);

    return apicid_die_offset(nr_dies, nr_cores, nr_threads) +

           apicid_die_width(nr_dies, nr_cores, nr_threads);

}



/* Make APIC ID for the CPU based on Pkg_ID, Core_ID, SMT_ID

 *

 * The caller must make sure core_id < nr_cores and smt_id < nr_threads.

 */

static inline apic_id_t apicid_from_topo_ids(unsigned nr_cores,

static inline apic_id_t apicid_from_topo_ids(unsigned nr_dies,

                                             unsigned nr_cores,

                                             unsigned nr_threads,

                                             const X86CPUTopoInfo *topo)

{

    return (topo->pkg_id  << apicid_pkg_offset(nr_cores, nr_threads)) |

           (topo->core_id << apicid_core_offset(nr_cores, nr_threads)) |

    return (topo->pkg_id  << apicid_pkg_offset(nr_dies, nr_cores, nr_threads)) |

           (topo->die_id  << apicid_die_offset(nr_dies, nr_cores, nr_threads)) |

          (topo->core_id << apicid_core_offset(nr_dies, nr_cores, nr_threads)) |

           topo->smt_id;

}



/* Calculate thread/core/package IDs for a specific topology,

 * based on (contiguous) CPU index

 */

static inline void x86_topo_ids_from_idx(unsigned nr_cores,

static inline void x86_topo_ids_from_idx(unsigned nr_dies,

                                         unsigned nr_cores,

                                         unsigned nr_threads,

                                         unsigned cpu_index,

                                         X86CPUTopoInfo *topo)

{

    unsigned core_index = cpu_index / nr_threads;

    topo->pkg_id = cpu_index / (nr_dies * nr_cores * nr_threads);

    topo->die_id = cpu_index / (nr_cores * nr_threads) % nr_dies;

    topo->core_id = cpu_index / nr_threads % nr_cores;

    topo->smt_id = cpu_index % nr_threads;

    topo->core_id = core_index % nr_cores;

    topo->pkg_id = core_index / nr_cores;

}



/* Calculate thread/core/package IDs for a specific topology,

 * based on APIC ID

 */

static inline void x86_topo_ids_from_apicid(apic_id_t apicid,

                                            unsigned nr_dies,

                                            unsigned nr_cores,

                                            unsigned nr_threads,

                                            X86CPUTopoInfo *topo)

{

    topo->smt_id = apicid &

                   ~(0xFFFFFFFFUL << apicid_smt_width(nr_cores, nr_threads));

    topo->core_id = (apicid >> apicid_core_offset(nr_cores, nr_threads)) &

                   ~(0xFFFFFFFFUL << apicid_core_width(nr_cores, nr_threads));

    topo->pkg_id = apicid >> apicid_pkg_offset(nr_cores, nr_threads);

    topo->die_id = 0;

            ~(0xFFFFFFFFUL << apicid_smt_width(nr_dies, nr_cores, nr_threads));

    topo->core_id =

            (apicid >> apicid_core_offset(nr_dies, nr_cores, nr_threads)) &

            ~(0xFFFFFFFFUL << apicid_core_width(nr_dies, nr_cores, nr_threads));

    topo->die_id =

            (apicid >> apicid_die_offset(nr_dies, nr_cores, nr_threads)) &

            ~(0xFFFFFFFFUL << apicid_die_width(nr_dies, nr_cores, nr_threads));

    topo->pkg_id = apicid >> apicid_pkg_offset(nr_dies, nr_cores, nr_threads);

}



/* Make APIC ID for the CPU 'cpu_index'

 *

 * 'cpu_index' is a sequential, contiguous ID for the CPU.

 */

static inline apic_id_t x86_apicid_from_cpu_idx(unsigned nr_cores,

static inline apic_id_t x86_apicid_from_cpu_idx(unsigned nr_dies,

                                                unsigned nr_cores,

                                                unsigned nr_threads,

                                                unsigned cpu_index)

{

    X86CPUTopoInfo topo;

    x86_topo_ids_from_idx(nr_cores, nr_threads, cpu_index, &topo);

    return apicid_from_topo_ids(nr_cores, nr_threads, &topo);

    x86_topo_ids_from_idx(nr_dies, nr_cores, nr_threads, cpu_index, &topo);

    return apicid_from_topo_ids(nr_dies, nr_cores, nr_threads, &topo);

}



#endif /* HW_I386_TOPOLOGY_H */

target/i386/cpu.c

+8 −5
Original line number Diff line number Diff line
@@ -4267,7 +4267,7 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count, 
{

    X86CPU *cpu = env_archcpu(env);

    CPUState *cs = env_cpu(env);

    uint32_t pkg_offset;

    uint32_t die_offset;

    uint32_t limit;

    uint32_t signature[3];
@@ -4356,10 +4356,11 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count, 
                                    eax, ebx, ecx, edx);

                break;

            case 3: /* L3 cache info */

                pkg_offset = apicid_pkg_offset(cs->nr_cores, cs->nr_threads);

                die_offset = apicid_die_offset(env->nr_dies,

                                        cs->nr_cores, cs->nr_threads);

                if (cpu->enable_l3_cache) {

                    encode_cache_cpuid4(env->cache_info_cpuid4.l3_cache,

                                        (1 << pkg_offset), cs->nr_cores,

                                        (1 << die_offset), cs->nr_cores,

                                        eax, ebx, ecx, edx);

                    break;

                }
@@ -4441,12 +4442,14 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count, 


        switch (count) {

        case 0:

            *eax = apicid_core_offset(cs->nr_cores, cs->nr_threads);

            *eax = apicid_core_offset(env->nr_dies,

                                      cs->nr_cores, cs->nr_threads);

            *ebx = cs->nr_threads;

            *ecx |= CPUID_TOPOLOGY_LEVEL_SMT;

            break;

        case 1:

            *eax = apicid_pkg_offset(cs->nr_cores, cs->nr_threads);

            *eax = apicid_pkg_offset(env->nr_dies,

                                     cs->nr_cores, cs->nr_threads);

            *ebx = cs->nr_cores * cs->nr_threads;

            *ecx |= CPUID_TOPOLOGY_LEVEL_CORE;

            break;

tests/test-x86-cpuid.c

+45 −39
Original line number Diff line number Diff line
@@ -28,74 +28,80 @@ 


static void test_topo_bits(void)

{

    /* simple tests for 1 thread per core, 1 core per socket */

    g_assert_cmpuint(apicid_smt_width(1, 1), ==, 0);

    g_assert_cmpuint(apicid_core_width(1, 1), ==, 0);

    /* simple tests for 1 thread per core, 1 core per die, 1 die per package */

    g_assert_cmpuint(apicid_smt_width(1, 1, 1), ==, 0);

    g_assert_cmpuint(apicid_core_width(1, 1, 1), ==, 0);

    g_assert_cmpuint(apicid_die_width(1, 1, 1), ==, 0);



    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 1, 0), ==, 0);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 1, 1), ==, 1);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 1, 2), ==, 2);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 1, 3), ==, 3);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 1, 1, 0), ==, 0);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 1, 1, 1), ==, 1);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 1, 1, 2), ==, 2);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 1, 1, 3), ==, 3);





    /* Test field width calculation for multiple values

     */

    g_assert_cmpuint(apicid_smt_width(1, 2), ==, 1);

    g_assert_cmpuint(apicid_smt_width(1, 3), ==, 2);

    g_assert_cmpuint(apicid_smt_width(1, 4), ==, 2);

    g_assert_cmpuint(apicid_smt_width(1, 1, 2), ==, 1);

    g_assert_cmpuint(apicid_smt_width(1, 1, 3), ==, 2);

    g_assert_cmpuint(apicid_smt_width(1, 1, 4), ==, 2);



    g_assert_cmpuint(apicid_smt_width(1, 14), ==, 4);

    g_assert_cmpuint(apicid_smt_width(1, 15), ==, 4);

    g_assert_cmpuint(apicid_smt_width(1, 16), ==, 4);

    g_assert_cmpuint(apicid_smt_width(1, 17), ==, 5);

    g_assert_cmpuint(apicid_smt_width(1, 1, 14), ==, 4);

    g_assert_cmpuint(apicid_smt_width(1, 1, 15), ==, 4);

    g_assert_cmpuint(apicid_smt_width(1, 1, 16), ==, 4);

    g_assert_cmpuint(apicid_smt_width(1, 1, 17), ==, 5);





    g_assert_cmpuint(apicid_core_width(30, 2), ==, 5);

    g_assert_cmpuint(apicid_core_width(31, 2), ==, 5);

    g_assert_cmpuint(apicid_core_width(32, 2), ==, 5);

    g_assert_cmpuint(apicid_core_width(33, 2), ==, 6);

    g_assert_cmpuint(apicid_core_width(1, 30, 2), ==, 5);

    g_assert_cmpuint(apicid_core_width(1, 31, 2), ==, 5);

    g_assert_cmpuint(apicid_core_width(1, 32, 2), ==, 5);

    g_assert_cmpuint(apicid_core_width(1, 33, 2), ==, 6);



    g_assert_cmpuint(apicid_die_width(1, 30, 2), ==, 0);

    g_assert_cmpuint(apicid_die_width(2, 30, 2), ==, 1);

    g_assert_cmpuint(apicid_die_width(3, 30, 2), ==, 2);

    g_assert_cmpuint(apicid_die_width(4, 30, 2), ==, 2);



    /* build a weird topology and see if IDs are calculated correctly

     */



    /* This will use 2 bits for thread ID and 3 bits for core ID

     */

    g_assert_cmpuint(apicid_smt_width(6, 3), ==, 2);

    g_assert_cmpuint(apicid_core_width(6, 3), ==, 3);

    g_assert_cmpuint(apicid_pkg_offset(6, 3), ==, 5);

    g_assert_cmpuint(apicid_smt_width(1, 6, 3), ==, 2);

    g_assert_cmpuint(apicid_core_offset(1, 6, 3), ==, 2);

    g_assert_cmpuint(apicid_die_offset(1, 6, 3), ==, 5);

    g_assert_cmpuint(apicid_pkg_offset(1, 6, 3), ==, 5);



    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 0), ==, 0);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 1), ==, 1);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 2), ==, 2);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 0), ==, 0);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 1), ==, 1);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 2), ==, 2);



    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 1 * 3 + 0), ==,

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 1 * 3 + 0), ==,

                     (1 << 2) | 0);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 1 * 3 + 1), ==,

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 1 * 3 + 1), ==,

                     (1 << 2) | 1);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 1 * 3 + 2), ==,

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 1 * 3 + 2), ==,

                     (1 << 2) | 2);



    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 2 * 3 + 0), ==,

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 2 * 3 + 0), ==,

                     (2 << 2) | 0);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 2 * 3 + 1), ==,

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 2 * 3 + 1), ==,

                     (2 << 2) | 1);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 2 * 3 + 2), ==,

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 2 * 3 + 2), ==,

                     (2 << 2) | 2);



    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 5 * 3 + 0), ==,

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 5 * 3 + 0), ==,

                     (5 << 2) | 0);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 5 * 3 + 1), ==,

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 5 * 3 + 1), ==,

                     (5 << 2) | 1);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 5 * 3 + 2), ==,

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3, 5 * 3 + 2), ==,

                     (5 << 2) | 2);



    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 1 * 6 * 3 + 0 * 3 + 0), ==,

                     (1 << 5));

    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 1 * 6 * 3 + 1 * 3 + 1), ==,

                     (1 << 5) | (1 << 2) | 1);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(6, 3, 3 * 6 * 3 + 5 * 3 + 2), ==,

                     (3 << 5) | (5 << 2) | 2);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3,

                     1 * 6 * 3 + 0 * 3 + 0), ==, (1 << 5));

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3,

                     1 * 6 * 3 + 1 * 3 + 1), ==, (1 << 5) | (1 << 2) | 1);

    g_assert_cmpuint(x86_apicid_from_cpu_idx(1, 6, 3,

                     3 * 6 * 3 + 5 * 3 + 2), ==, (3 << 5) | (5 << 2) | 2);

}



int main(int argc, char **argv)