hw/386: Add EPYC mode topology decoding functions
[qemu.git] / include / hw / i386 / topology.h
1 /*
2 * x86 CPU topology data structures and functions
3 *
4 * Copyright (c) 2012 Red Hat Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #ifndef HW_I386_TOPOLOGY_H
25 #define HW_I386_TOPOLOGY_H
26
27 /* This file implements the APIC-ID-based CPU topology enumeration logic,
28 * documented at the following document:
29 * IntelĀ® 64 Architecture Processor Topology Enumeration
30 * http://software.intel.com/en-us/articles/intel-64-architecture-processor-topology-enumeration/
31 *
32 * This code should be compatible with AMD's "Extended Method" described at:
33 * AMD CPUID Specification (Publication #25481)
34 * Section 3: Multiple Core Calcuation
35 * as long as:
36 * nr_threads is set to 1;
37 * OFFSET_IDX is assumed to be 0;
38 * CPUID Fn8000_0008_ECX[ApicIdCoreIdSize[3:0]] is set to apicid_core_width().
39 */
40
41
42 #include "qemu/bitops.h"
43
44 /* APIC IDs can be 32-bit, but beware: APIC IDs > 255 require x2APIC support
45 */
46 typedef uint32_t apic_id_t;
47
48 typedef struct X86CPUTopoIDs {
49 unsigned pkg_id;
50 unsigned node_id;
51 unsigned die_id;
52 unsigned core_id;
53 unsigned smt_id;
54 } X86CPUTopoIDs;
55
56 typedef struct X86CPUTopoInfo {
57 unsigned nodes_per_pkg;
58 unsigned dies_per_pkg;
59 unsigned cores_per_die;
60 unsigned threads_per_core;
61 } X86CPUTopoInfo;
62
63 /* Return the bit width needed for 'count' IDs
64 */
65 static unsigned apicid_bitwidth_for_count(unsigned count)
66 {
67 g_assert(count >= 1);
68 count -= 1;
69 return count ? 32 - clz32(count) : 0;
70 }
71
72 /* Bit width of the SMT_ID (thread ID) field on the APIC ID
73 */
74 static inline unsigned apicid_smt_width(X86CPUTopoInfo *topo_info)
75 {
76 return apicid_bitwidth_for_count(topo_info->threads_per_core);
77 }
78
79 /* Bit width of the Core_ID field
80 */
81 static inline unsigned apicid_core_width(X86CPUTopoInfo *topo_info)
82 {
83 return apicid_bitwidth_for_count(topo_info->cores_per_die);
84 }
85
86 /* Bit width of the Die_ID field */
87 static inline unsigned apicid_die_width(X86CPUTopoInfo *topo_info)
88 {
89 return apicid_bitwidth_for_count(topo_info->dies_per_pkg);
90 }
91
92 /* Bit width of the node_id field per socket */
93 static inline unsigned apicid_node_width_epyc(X86CPUTopoInfo *topo_info)
94 {
95 return apicid_bitwidth_for_count(MAX(topo_info->nodes_per_pkg, 1));
96 }
97 /* Bit offset of the Core_ID field
98 */
99 static inline unsigned apicid_core_offset(X86CPUTopoInfo *topo_info)
100 {
101 return apicid_smt_width(topo_info);
102 }
103
104 /* Bit offset of the Die_ID field */
105 static inline unsigned apicid_die_offset(X86CPUTopoInfo *topo_info)
106 {
107 return apicid_core_offset(topo_info) + apicid_core_width(topo_info);
108 }
109
110 /* Bit offset of the Pkg_ID (socket ID) field
111 */
112 static inline unsigned apicid_pkg_offset(X86CPUTopoInfo *topo_info)
113 {
114 return apicid_die_offset(topo_info) + apicid_die_width(topo_info);
115 }
116
117 #define NODE_ID_OFFSET 3 /* Minimum node_id offset if numa configured */
118
119 /*
120 * Bit offset of the node_id field
121 *
122 * Make sure nodes_per_pkg > 0 if numa configured else zero.
123 */
124 static inline unsigned apicid_node_offset_epyc(X86CPUTopoInfo *topo_info)
125 {
126 unsigned offset = apicid_die_offset(topo_info) +
127 apicid_die_width(topo_info);
128
129 if (topo_info->nodes_per_pkg) {
130 return MAX(NODE_ID_OFFSET, offset);
131 } else {
132 return offset;
133 }
134 }
135
136 /* Bit offset of the Pkg_ID (socket ID) field */
137 static inline unsigned apicid_pkg_offset_epyc(X86CPUTopoInfo *topo_info)
138 {
139 return apicid_node_offset_epyc(topo_info) +
140 apicid_node_width_epyc(topo_info);
141 }
142
143 /*
144 * Make APIC ID for the CPU based on Pkg_ID, Core_ID, SMT_ID
145 *
146 * The caller must make sure core_id < nr_cores and smt_id < nr_threads.
147 */
148 static inline apic_id_t
149 x86_apicid_from_topo_ids_epyc(X86CPUTopoInfo *topo_info,
150 const X86CPUTopoIDs *topo_ids)
151 {
152 return (topo_ids->pkg_id << apicid_pkg_offset_epyc(topo_info)) |
153 (topo_ids->node_id << apicid_node_offset_epyc(topo_info)) |
154 (topo_ids->die_id << apicid_die_offset(topo_info)) |
155 (topo_ids->core_id << apicid_core_offset(topo_info)) |
156 topo_ids->smt_id;
157 }
158
159 static inline void x86_topo_ids_from_idx_epyc(X86CPUTopoInfo *topo_info,
160 unsigned cpu_index,
161 X86CPUTopoIDs *topo_ids)
162 {
163 unsigned nr_nodes = MAX(topo_info->nodes_per_pkg, 1);
164 unsigned nr_dies = topo_info->dies_per_pkg;
165 unsigned nr_cores = topo_info->cores_per_die;
166 unsigned nr_threads = topo_info->threads_per_core;
167 unsigned cores_per_node = DIV_ROUND_UP((nr_dies * nr_cores * nr_threads),
168 nr_nodes);
169
170 topo_ids->pkg_id = cpu_index / (nr_dies * nr_cores * nr_threads);
171 topo_ids->node_id = (cpu_index / cores_per_node) % nr_nodes;
172 topo_ids->die_id = cpu_index / (nr_cores * nr_threads) % nr_dies;
173 topo_ids->core_id = cpu_index / nr_threads % nr_cores;
174 topo_ids->smt_id = cpu_index % nr_threads;
175 }
176
177 /*
178 * Calculate thread/core/package IDs for a specific topology,
179 * based on APIC ID
180 */
181 static inline void x86_topo_ids_from_apicid_epyc(apic_id_t apicid,
182 X86CPUTopoInfo *topo_info,
183 X86CPUTopoIDs *topo_ids)
184 {
185 topo_ids->smt_id = apicid &
186 ~(0xFFFFFFFFUL << apicid_smt_width(topo_info));
187 topo_ids->core_id =
188 (apicid >> apicid_core_offset(topo_info)) &
189 ~(0xFFFFFFFFUL << apicid_core_width(topo_info));
190 topo_ids->die_id =
191 (apicid >> apicid_die_offset(topo_info)) &
192 ~(0xFFFFFFFFUL << apicid_die_width(topo_info));
193 topo_ids->node_id =
194 (apicid >> apicid_node_offset_epyc(topo_info)) &
195 ~(0xFFFFFFFFUL << apicid_node_width_epyc(topo_info));
196 topo_ids->pkg_id = apicid >> apicid_pkg_offset_epyc(topo_info);
197 }
198
199 /*
200 * Make APIC ID for the CPU 'cpu_index'
201 *
202 * 'cpu_index' is a sequential, contiguous ID for the CPU.
203 */
204 static inline apic_id_t x86_apicid_from_cpu_idx_epyc(X86CPUTopoInfo *topo_info,
205 unsigned cpu_index)
206 {
207 X86CPUTopoIDs topo_ids;
208 x86_topo_ids_from_idx_epyc(topo_info, cpu_index, &topo_ids);
209 return x86_apicid_from_topo_ids_epyc(topo_info, &topo_ids);
210 }
211 /* Make APIC ID for the CPU based on Pkg_ID, Core_ID, SMT_ID
212 *
213 * The caller must make sure core_id < nr_cores and smt_id < nr_threads.
214 */
215 static inline apic_id_t x86_apicid_from_topo_ids(X86CPUTopoInfo *topo_info,
216 const X86CPUTopoIDs *topo_ids)
217 {
218 return (topo_ids->pkg_id << apicid_pkg_offset(topo_info)) |
219 (topo_ids->die_id << apicid_die_offset(topo_info)) |
220 (topo_ids->core_id << apicid_core_offset(topo_info)) |
221 topo_ids->smt_id;
222 }
223
224 /* Calculate thread/core/package IDs for a specific topology,
225 * based on (contiguous) CPU index
226 */
227 static inline void x86_topo_ids_from_idx(X86CPUTopoInfo *topo_info,
228 unsigned cpu_index,
229 X86CPUTopoIDs *topo_ids)
230 {
231 unsigned nr_dies = topo_info->dies_per_pkg;
232 unsigned nr_cores = topo_info->cores_per_die;
233 unsigned nr_threads = topo_info->threads_per_core;
234
235 topo_ids->pkg_id = cpu_index / (nr_dies * nr_cores * nr_threads);
236 topo_ids->die_id = cpu_index / (nr_cores * nr_threads) % nr_dies;
237 topo_ids->core_id = cpu_index / nr_threads % nr_cores;
238 topo_ids->smt_id = cpu_index % nr_threads;
239 }
240
241 /* Calculate thread/core/package IDs for a specific topology,
242 * based on APIC ID
243 */
244 static inline void x86_topo_ids_from_apicid(apic_id_t apicid,
245 X86CPUTopoInfo *topo_info,
246 X86CPUTopoIDs *topo_ids)
247 {
248 topo_ids->smt_id = apicid &
249 ~(0xFFFFFFFFUL << apicid_smt_width(topo_info));
250 topo_ids->core_id =
251 (apicid >> apicid_core_offset(topo_info)) &
252 ~(0xFFFFFFFFUL << apicid_core_width(topo_info));
253 topo_ids->die_id =
254 (apicid >> apicid_die_offset(topo_info)) &
255 ~(0xFFFFFFFFUL << apicid_die_width(topo_info));
256 topo_ids->pkg_id = apicid >> apicid_pkg_offset(topo_info);
257 }
258
259 /* Make APIC ID for the CPU 'cpu_index'
260 *
261 * 'cpu_index' is a sequential, contiguous ID for the CPU.
262 */
263 static inline apic_id_t x86_apicid_from_cpu_idx(X86CPUTopoInfo *topo_info,
264 unsigned cpu_index)
265 {
266 X86CPUTopoIDs topo_ids;
267 x86_topo_ids_from_idx(topo_info, cpu_index, &topo_ids);
268 return x86_apicid_from_topo_ids(topo_info, &topo_ids);
269 }
270
271 #endif /* HW_I386_TOPOLOGY_H */