En la arquitectura x86 , la instrucción CPUID (identificada por un CPUID
código de operación ) es una instrucción suplementaria del procesador (su nombre se deriva de CPU IDentification) que permite al software descubrir detalles del procesador. Fue introducido por Intel en 1993 con el lanzamiento de los procesadores Pentium y 486 mejorados con SL . [1]
Un programa puede utilizar CPUID
para determinar el tipo de procesador y si se implementan funciones como MMX / SSE .
Historia
Antes de la disponibilidad general de la CPUID
instrucción, los programadores escribirían código de máquina esotérico que explotaba diferencias menores en el comportamiento de la CPU para determinar la marca y el modelo del procesador. [2] [3] Con la introducción del procesador 80386, EDX en el reinicio indicaba la revisión, pero esto solo se podía leer después del reinicio y no había una forma estándar para que las aplicaciones leyeran el valor.
Fuera de la familia x86, los desarrolladores todavía deben usar procesos esotéricos (que involucran tiempos de instrucción o desencadenantes de fallas de la CPU) para determinar las variaciones en el diseño de la CPU que están presentes.
En la familia Motorola 680x0, que nunca tuvo una instrucción CPUID de ningún tipo, ciertas instrucciones específicas requerían privilegios elevados. Estos podrían usarse para diferenciar a varios miembros de la familia de CPU. En el Motorola 68010 se privilegió la instrucción MOVE de SR . Este notable cambio de instrucción (y máquina de estado) permitió que el 68010 cumpliera con los requisitos de virtualización de Popek y Goldberg . Debido a que el 68000 ofrecía un MOVE sin privilegios de SR, las 2 CPU diferentes podían distinguirse mediante la activación de una condición de error de la CPU.
Si bien la CPUID
instrucción es específica de la arquitectura x86, otras arquitecturas (como ARM) a menudo proporcionan registros en el chip que se pueden leer de formas prescritas para obtener el mismo tipo de información proporcionada por la instrucción CPUID x86.
Llamando CPUID
El CPUID
código de operación es 0Fh, A2h
(como dos bytes o A20Fh
como uno solo word
).
En lenguaje ensamblador , la CPUID
instrucción no toma parámetros ya que CPUID
implícitamente usa el registro EAX para determinar la categoría principal de información devuelta. En la terminología más reciente de Intel, esto se denomina hoja CPUID. CPUID
debe llamarse con EAX = 0
primero, ya que esto almacenará en el registro EAX el parámetro de llamada EAX más alto (hoja) que implemente la CPU.
Para obtener información de función extendida, se CPUID
debe llamar con el bit más significativo del conjunto EAX. Para determinar el parámetro de llamada de función extendida más alto, llame CPUID
con EAX = 80000000h
.
Las hojas de CPUID mayores que 3 pero menos de 80000000 son accesibles solo cuando los registros específicos del modelo tienen IA32_MISC_ENABLE.BOOT_NT4 [bit 22] = 0 (que es así por defecto). Como sugiere el nombre, Windows NT 4.0 hasta SP6 no arrancaba correctamente a menos que se estableciera este bit, [4] [ enlace muerto ] pero las versiones posteriores de Windows no lo necesitan, por lo que las hojas básicas superiores a 4 se pueden asumir visibles en Windows actual sistemas. A julio de 2014[actualizar], las licencias básicas válidas van hasta las 14h, pero la información devuelta por algunas hojas no se divulga en la documentación disponible públicamente, es decir, están "reservadas".
Algunas de las hojas agregadas más recientemente también tienen subhojas, que se seleccionan a través del registro ECX antes de llamar a CPUID.
EAX = 0: Parámetro de función más alto e ID de fabricante
Esto devuelve la cadena de identificación del fabricante de la CPU, una cadena ASCII de doce caracteres almacenada en EBX, EDX, ECX (en ese orden). El parámetro de llamada básico más alto (el valor más alto al que se puede establecer EAX antes de llamar CPUID
) se devuelve en EAX.
Aquí hay una lista de procesadores y la función más alta implementada.
Procesadores | Básico | Extendido |
---|---|---|
A principios de Intel 486 | CPUID no implementado | |
Posteriormente Intel 486 y Pentium | 0x01 | No se ha implementado |
Pentium Pro , Pentium II y Celeron | 0x02 | No se ha implementado |
Pentium III | 0x03 | No se ha implementado |
Pentium 4 | 0x02 | 0x8000 0004 |
Xeon | 0x02 | 0x8000 0004 |
Pentium M | 0x02 | 0x8000 0004 |
Pentium 4 con Hyper-Threading | 0x05 | 0x8000 0008 |
Pentium D (8xx) | 0x05 | 0x8000 0008 |
Pentium D (9xx) | 0x06 | 0x8000 0008 |
Core Duo | 0x0A | 0x8000 0008 |
2 núcleos, duales | 0x0A | 0x8000 0008 |
Xeon 3000 , 5100, 5200, 5300, 5400 ( serie 5000 ) | 0x0A | 0x8000 0008 |
Serie Core 2 Duo 8000 | 0x0D | 0x8000 0008 |
Serie Xeon 5200, 5400 | 0x0A | 0x8000 0008 |
Átomo | 0x0A | 0x8000 0008 |
Procesadores basados en Nehalem | 0x0B | 0x8000 0008 |
Procesadores basados en Ivy Bridge | 0x0D | 0x8000 0008 |
Procesadores basados en Skylake (proc base y max freq; bus ref. Freq) | 0x16 | 0x8000 0008 |
Hoja principal de enumeración de atributos de proveedor de System-on-Chip | 0x17 | 0x8000 0008 |
Las siguientes son cadenas de ID de fabricante de procesador conocidas:
"AMDisbetter!"
- muestras de ingeniería temprana de AMD K5 procesador"AuthenticAMD"
- AMD"CentaurHauls"
- IDT WinChip / Centaur (Incluyendo algunas CPU VIA)"CyrixInstead"
- Cyrix / primeros STMicroelectronics e IBM"GenuineIntel"
- Intel"TransmetaCPU"
- Transmeta"GenuineTMx86"
- Transmeta"Geode by NSC"
- Semiconductor nacional"NexGenDriven"
- NexGen"RiseRiseRise"
- subir"SiS SiS SiS "
- SiS"UMC UMC UMC "
- UMC"VIA VIA VIA "
- VIA"Vortex86 SoC"
- Vórtice DM&P" Shanghai "
- Zhaoxin"HygonGenuine"
- Hygon"E2K MACHINE"
- MCST Elbrus
Las siguientes son cadenas de ID utilizadas por núcleos de CPU de software de código abierto :
"GenuineAO486"
- CPU ao486 [5]"GenuineIntel"
- núcleo v586 [6] (es idéntico a la cadena de ID de Intel)
Las siguientes son cadenas de ID conocidas de máquinas virtuales:
"bhyve bhyve "
- bhyve" KVMKVMKVM "
- KVM"TCGTCGTCGTCG"
- QEMU"Microsoft Hv"
- Microsoft Hyper-V o Windows Virtual PC" lrpepyh vr"
- Paralelos (posiblemente debería ser "prl hyperv", pero está codificado como "lrpepyh vr" debido a un desajuste de endianness )"VMwareVMware"
- VMware"XenVMMXenVMM"
- Xen HVM"ACRNACRNACRN"
- Proyecto ACRN" QNXQVMBSQG "
- Hipervisor QNX"VirtualApple"
- Manzana Rosetta"GenuineIntel"
- Apple Rosetta 2 [7]
Por ejemplo, en un procesador GenuineIntel, los valores devueltos en EBX son 0x756e6547, EDX es 0x49656e69 y ECX es 0x6c65746e. El siguiente código está escrito en GNU Assembler para la arquitectura x86-64 y muestra la cadena de identificación del proveedor, así como el parámetro de llamada más alto que implementa la CPU.
.datoss0: .asciz "CPUID:% x \ n" s1: .asciz "Número de función básica más grande implementado:% i \ n" s2: .asciz "ID de proveedor:% .12s \ n".texto.align 32 .globl principalprincipal: pushq % rbp movq % rsp , % rbp subq $ 16 , % rspmovl $ 1 , % eax cpuidmovq $ s0 , % rdi movl % eax , % esi xorl % eax , % eax llamar printfpushq % rbx // -fPICxorl % eax , % eax cpuidmovl % ebx , 0 ( % rsp ) movl % edx , 4 ( % rsp ) movl % ecx , 8 ( % rsp )popq % rbx // -fPICmovq $ s1 , % rdi movl % eax , % esi xorl % eax , % eax llamar printfmovq $ s2 , % rdi movq % rsp , % rsi xorl % eax , % eax llamar printfmovq % rbp , % rsp popq % rbp // ret movl $ 1 , % eax int $ 0x80
EAX = 1: Información del procesador y bits de funciones
Esto devuelve la información de pasos , modelos y familias de la CPU en el registro EAX (también llamado firma de una CPU), indicadores de funciones en los registros EDX y ECX, e información adicional de funciones en el registro EBX. [8]
EAX | |||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
31 | 30 | 29 | 28 | 27 | 26 | 25 | 24 | 23 | 22 | 21 | 20 | 19 | 18 | 17 | dieciséis | 15 | 14 | 13 | 12 | 11 | 10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
Reservado | Identificación de familia extendida | ID de modelo extendido | Reservado | Tipo de procesador | Identificación familiar | Modelo | ID de paso |
- Stepping ID es un número de revisión de producto asignado debido a erratas fijas u otros cambios.
- El modelo de procesador real se deriva de los campos Modelo, ID de modelo extendido e ID de familia. Si el campo ID de familia es 6 o 15, el modelo es igual a la suma del campo ID de modelo extendido desplazado a la izquierda en 4 bits y el campo Modelo. De lo contrario, el modelo es igual al valor del campo Modelo.
- La familia de procesadores real se deriva de los campos Identificación de familia e Identificación de familia extendida. Si el campo de identificación de familia es igual a 15, la familia es igual a la suma de los campos de identificación de familia extendida e identificación de familia. De lo contrario, la familia es igual al valor del campo ID de familia.
- El significado del campo Tipo de procesador se indica en la siguiente tabla.
Tipo | Codificación en binario |
---|---|
Procesador de fabricante de equipo original ( OEM ) | 00 |
Procesador Intel Overdrive | 01 |
Procesador dual (no aplicable a procesadores Intel486) | 10 |
Valor reservado | 11 |
Bits | EBX | Válido |
---|---|---|
7: 0 | Índice de marca | |
15: 8 | Tamaño de línea CLFLUSH (Valor. 8 = tamaño de línea de caché en bytes) | si el indicador de función CLFLUSH está establecido. CPUID.01.EDX.CLFSH [bit 19] = 1 |
23:16 | Número máximo de ID direccionables para procesadores lógicos en este paquete físico; El número entero de potencia de 2 más cercano que no es menor que este valor es el número de ID APIC iniciales únicos reservados para direccionar diferentes procesadores lógicos en un paquete físico. Uso anterior: número de procesadores lógicos por procesador físico; dos para el procesador Pentium 4 con tecnología Hyper-Threading. [9] | si se establece el indicador de función Hyper-Threading . CPUID.01.EDX.HTT [bit 28] = 1 |
31:24 | ID de APIC local: el ID de APIC inicial se utiliza para identificar el procesador lógico en ejecución. También se puede identificar a través de la hoja cpuid 0BH (CPUID.0Bh.EDX [x2APIC-ID]). | Pentium 4 y procesadores posteriores. |
La información del procesador y los indicadores de funciones son específicos del fabricante, pero normalmente otros fabricantes utilizan los valores de Intel en aras de la compatibilidad.
Un poco | EDX | ECX | ||
---|---|---|---|---|
Corto | Característica | Corto | Característica | |
0 | fpu | FPU x87 integrado | sse3 | Nuevas instrucciones de Prescott -SSE3 (PNI) |
1 | vme | Extensiones de modo virtual 8086 (como VIF, VIP, PIV) | pclmulqdq | PCLMULQDQ |
2 | Delaware | Extensiones de depuración ( CR4 bit 3) | dtes64 | Almacén de depuración de 64 bits (edx bit 21) |
3 | pse | Extensión de tamaño de página | monitor | Instrucciones MONITOR y MWAIT ( SSE3 ) |
4 | tsc | Contador de marca de tiempo | ds-cpl | Tienda de depuración calificada por CPL |
5 | msr | Registros específicos del modelo | vmx | Extensiones de máquinas virtuales |
6 | pae | Extensión de dirección física | smx | Extensiones de modo más seguro ( LaGrande ) |
7 | mce | Excepción de verificación de máquina | est | SpeedStep mejorado |
8 | cx8 | Instrucción CMPXCHG8 ( comparar e intercambiar ) | tm2 | Monitor térmico 2 |
9 | apic | Controlador de interrupciones programable avanzado integrado | ssse3 | Instrucciones suplementarias de SSE3 |
10 | (reservado) | cnxt-id | ID de contexto L1 | |
11 | sep | Instrucciones SYSENTER y SYSEXIT | sdbg | Interfaz de depuración de silicio |
12 | mtrr | Registros de rango de tipo de memoria | fma | Multiplicar-agregar fusionado (FMA3) |
13 | pge | Bit de habilitación global de página en CR4 | cx16 | Instrucción CMPXCHG16B |
14 | mca | Arquitectura de verificación de máquina | xtpr | Puede deshabilitar el envío de mensajes de prioridad de tareas. |
15 | cmov | Movimiento condicional e instrucciones FCMOV | pdcm | Capacidad de depuración y rendimiento |
dieciséis | palmadita | Tabla de atributos de página | (reservado) | |
17 | pse-36 | Extensión de tamaño de página de 36 bits | pcid | Identificadores de contexto de proceso ( CR4 bit 17) |
18 | psn | Número de serie del procesador | dca | Acceso directo a la caché para escrituras DMA [10] [11] |
19 | clfsh | Instrucción CLFLUSH ( SSE2 ) | sse4.1 | Instrucciones SSE4.1 |
20 | (reservado) | sse4.2 | Instrucciones SSE4.2 | |
21 | ds | Almacén de depuración: guarda el rastro de los saltos ejecutados | x2apic | x2APIC |
22 | acpi | MSR de control térmico a bordo para ACPI | movbe | Instrucción MOVBE ( big-endian ) |
23 | mmx | Instrucciones MMX | popcnt | Instrucción POPCNT |
24 | fxsr | Instrucciones FXSAVE, FXRESTOR, CR4 bit 9 | tsc-deadline | APIC implementa una operación de una sola vez utilizando un valor de fecha límite de TSC |
25 | sse | Instrucciones SSE (también conocidas como Katmai New Instructions) | aes | Conjunto de instrucciones AES |
26 | sse2 | Instrucciones SSE2 | xsave | XSAVE, XRESTOR, XSETBV, XGETBV |
27 | ss | La caché de la CPU implementa self- snoop | osxsave | XSAVE habilitado por el sistema operativo |
28 | http: // www. | Hyper-threading | avx | Extensiones de vector avanzadas |
29 | tm | El monitor térmico limita automáticamente la temperatura | f16c | Función FP F16C ( precisión media ) |
30 | ia64 | Procesador IA64 emulando x86 | rdrnd | Función RDRAND (generador de números aleatorios en chip) |
31 | pbe | Capacidad de activación de habilitación de interrupción pendiente (pin PBE #) | hipervisor | Hipervisor presente (siempre cero en CPU físicas) [12] [13] |
Los campos reservados deben enmascararse antes de usarlos con fines de identificación del procesador.
EAX = 2: caché y descriptor TLB información
Esto devuelve una lista de descriptores que indican las capacidades de caché y TLB en los registros EAX, EBX, ECX y EDX.
EAX = 3: Número de serie del procesador
Esto devuelve el número de serie del procesador. El número de serie del procesador se introdujo en Intel Pentium III , pero debido a problemas de privacidad, esta función ya no se implementa en modelos posteriores (el bit de función PSN siempre se borra). Los procesadores Efficeon y Crusoe de Transmeta también ofrecen esta característica. Sin embargo, las CPU AMD no implementan esta función en ningún modelo de CPU.
Para las CPU Intel Pentium III, el número de serie se devuelve en los registros EDX: ECX. Para las CPU Transmeta Efficeon, se devuelve en los registros EBX: EAX. Y para las CPU Transmeta Crusoe, se devuelve solo en el registro EBX.
Tenga en cuenta que la función del número de serie del procesador debe estar habilitada en la configuración del BIOS para que funcione.
EAX = 4 y EAX = Bh: topología de subproceso / núcleo y caché de Intel
Estas dos hojas se utilizan para la topología del procesador (subproceso, núcleo, paquete) y la enumeración de la jerarquía de la memoria caché en los procesadores Intel de múltiples núcleos (e hiperproceso). [14] A partir de 2013[actualizar]AMD no usa estas hojas, pero tiene formas alternativas de hacer la enumeración del núcleo. [15]
A diferencia de la mayoría de las hojas de CPUID, la hoja Bh devolverá diferentes valores en EDX dependiendo del procesador lógico que ejecute la instrucción CPUID; el valor devuelto en EDX es en realidad el id x2APIC del procesador lógico. Sin embargo, el espacio de identificación de x2APIC no se asigna continuamente a procesadores lógicos; puede haber espacios en el mapeo, lo que significa que algunos identificadores de x2APIC intermedios no corresponden necesariamente a ningún procesador lógico. En los otros registros se proporciona información adicional para mapear los ID de x2APIC a los núcleos. Aunque la hoja Bh tiene sub-hojas (seleccionadas por ECX como se describe más adelante), el valor devuelto en EDX solo se ve afectado por el procesador lógico en el que se ejecuta la instrucción, pero no por el subleaf.
La topología del procesador (s) expuesta por la hoja Bh es jerárquica, pero con la extraña advertencia de que el orden de los niveles (lógicos) en esta jerarquía no corresponde necesariamente al orden en la jerarquía física ( SMT / core / paquete). Sin embargo, cada nivel lógico puede consultarse como una subhabla ECX (de la hoja Bh) para su correspondencia con un "tipo de nivel", que puede ser SMT, núcleo o "inválido". El espacio de identificación de nivel comienza en 0 y es continuo, lo que significa que si una identificación de nivel no es válida, todos los identificadores de nivel superior también serán inválidos. El tipo de nivel se devuelve en los bits 15:08 de ECX, mientras que el número de procesadores lógicos en el nivel consultado se devuelve en EBX. Finalmente, la conexión entre estos niveles y los identificadores de x2APIC se devuelve en EAX [4: 0] como el número de bits que el identificador de x2APIC debe desplazarse para obtener un identificador único en el siguiente nivel.
Como ejemplo, un procesador Westmere de doble núcleo capaz de hyperthreading (por lo tanto, tiene dos núcleos y cuatro subprocesos en total) podría tener los identificadores x2APIC 0, 1, 4 y 5 para sus cuatro procesadores lógicos. Leaf Bh (= EAX), subleaf 0 (= ECX) de CPUID podría, por ejemplo, devolver 100h en ECX, lo que significa que el nivel 0 describe la capa SMT (hyperthreading) y devolver 2 en EBX porque hay dos procesadores lógicos (unidades SMT) por núcleo físico. El valor devuelto en EAX para este 0-subbleaf debe ser 1 en este caso, porque el desplazamiento de los identificadores x2APIC mencionados anteriormente hacia la derecha un bit da un número de núcleo único (en el siguiente nivel de la jerarquía de id de nivel) y borra el id de SMT poco dentro de cada núcleo. Una forma más sencilla de interpretar esta información es que el último bit (bit número 0) de la identificación x2APIC identifica la unidad SMT / hyperthreading dentro de cada núcleo en nuestro ejemplo. Avanzar a subleaf 1 (haciendo otra llamada a CPUID con EAX = Bh y ECX = 1) podría, por ejemplo, devolver 201h en ECX, lo que significa que este es un nivel de tipo de núcleo, y 4 en EBX porque hay 4 procesadores lógicos en el paquete; EAX devuelto podría ser cualquier valor mayor que 3, porque sucede que el bit número 2 se usa para identificar el núcleo en el id x2APIC. Tenga en cuenta que el bit número 1 de la identificación x2APIC no se utiliza en este ejemplo. Sin embargo, EAX devuelto en este nivel bien podría ser 4 (y resulta ser así en un Clarkdale Core i3 5x0) porque eso también da una identificación única a nivel de paquete (= 0 obviamente) al cambiar la identificación x2APIC en 4 bits. Finalmente, puede que se pregunte qué puede decirnos la hoja EAX = 4 que aún no descubrimos. En EAX [31:26] devuelve los bits de máscara APIC reservados para un paquete; eso sería 111b en nuestro ejemplo porque los bits 0 a 2 se usan para identificar procesadores lógicos dentro de este paquete, pero el bit 1 también está reservado aunque no se usa como parte del esquema de identificación del procesador lógico. En otras palabras, los identificadores APIC 0 a 7 están reservados para el paquete, aunque la mitad de estos valores no se asignan a un procesador lógico.
La jerarquía de caché del procesador se explora observando las sub-hojas de la hoja 4. Los identificadores de APIC también se utilizan en esta jerarquía para transmitir información sobre cómo los diferentes niveles de caché son compartidos por las unidades SMT y los núcleos. Para continuar con nuestro ejemplo, la caché L2, que es compartida por unidades SMT del mismo núcleo pero no entre núcleos físicos en Westmere, se indica mediante EAX [26:14] que se establece en 1, mientras que la información de que la caché L3 se comparte por el paquete completo se indica estableciendo esos bits en (al menos) 111b. Los detalles de la caché, incluido el tipo, el tamaño y la asociatividad de la caché, se comunican a través de los otros registros de la hoja 4.
Tenga en cuenta que las versiones anteriores de la nota 485 de la aplicación Intel contienen información engañosa, en particular con respecto a la identificación y el recuento de núcleos en un procesador de múltiples núcleos; [16] incluso se han incorporado errores por malinterpretar esta información en el código de muestra de Microsoft para el uso de cpuid, incluso para la edición 2013 de Visual Studio, [17] y también en la página sandpile.org para CPUID, [18] pero Intel El ejemplo de código para identificar la topología del procesador [14] tiene la interpretación correcta y el Manual del desarrollador de software Intel actual tiene un lenguaje más claro. El código de producción multiplataforma (de código abierto) [19] de Wildfire Games también implementa la interpretación correcta de la documentación de Intel.
En una presentación de Intel de 2010 se dan ejemplos de detección de topología que involucran procesadores Intel más antiguos (anteriores a 2010) que carecen de x2APIC (por lo tanto, no implementan la hoja EAX = Bh). [20] Tenga en cuenta que el uso de ese método de detección más antiguo en 2010 y los procesadores Intel más nuevos puede sobrestimar la cantidad de núcleos y procesadores lógicos porque el método de detección anterior asume que no hay brechas en el espacio de identificación APIC, y algunos procesadores más nuevos violan esta suposición (comenzando con la serie Core i3 5x0), pero estos procesadores más nuevos también vienen con un x2APIC, por lo que su topología se puede determinar correctamente usando el método de hoja EAX = Bh.
EAX = 6: Gestión térmica y energética
EAX = 7, ECX = 0: Funciones ampliadas
Esto devuelve indicadores de funciones extendidas en EBX, ECX y EDX. Devuelve el valor ECX máximo para EAX = 7 en EAX.
Un poco | EBX | ECX | EDX | |||
---|---|---|---|---|---|---|
Corto | Característica | Corto | Característica | Corto | Característica | |
0 | fsgsbase | Acceso a la base de% fs y% gs | prefetchwt1 | Instrucción PREFETCHWT1 | (reservado) | |
1 | IA32_TSC_ADJUST | avx512_vbmi | Instrucciones de manipulación de bits vectoriales AVX-512 | (reservado) | ||
2 | sgx | Extensiones de protección de software | umip | Prevención de instrucciones en modo de usuario | avx512_4vnniw | Instrucciones para la red neuronal de 4 registros AVX-512 |
3 | bmi1 | Conjunto de instrucciones de manipulación de bits 1 | pku | Claves de protección de memoria para páginas en modo de usuario | avx512_4fmaps | AVX-512 Acumulación multiplicada de 4 registros Precisión simple |
4 | hle | Elisión de bloqueo de hardware TSX | ospke | PKU habilitado por el sistema operativo | fsrm | MOVSB de REP rápido y corto |
5 | avx2 | Extensiones vectoriales avanzadas 2 | esperar | Pausa temporizada y monitorización / espera a nivel de usuario | (reservado) | |
6 | FDP_EXCPTN_ONLY | avx512_vbmi2 | Instrucciones de manipulación de bits vectoriales AVX-512 2 | |||
7 | smep | Prevención de ejecución en modo supervisor | cet_ss | Pila de sombra de aplicación de flujo de control (CET) | ||
8 | bmi2 | Conjunto de instrucciones de manipulación de bits 2 | gfni | Instrucciones de Galois Field | avx512_vp2intersect | AVX-512 VP2INTERSECT Instrucciones de palabra doble y cuádruple |
9 | erms | REP MOVSB / STOSB mejorado | vaes | Conjunto de instrucciones Vector AES (VEX-256 / EVEX) | SRBDS_CTRL | Mitigaciones de muestreo de datos de búfer de registro especial |
10 | invpcid | Instrucción INVPCID | vpclmulqdq | Conjunto de instrucciones CLMUL (VEX-256 / EVEX) | md_clear | La instrucción VERW borra los búferes de la CPU |
11 | rtm | Memoria transaccional restringida TSX | avx512_vnni | Instrucciones para la red neuronal vectorial AVX-512 | (reservado) | |
12 | pqm | Supervisión de la calidad del servicio de la plataforma | avx512_bitalg | Instrucciones AVX-512 BITALG | ||
13 | FPU CS y FPU DS en desuso | (reservado) | tsx_force_abort | |||
14 | mpx | Intel MPX (extensiones de protección de memoria) | avx512_vpopcntdq | Recuento de población vectorial AVX-512 palabras dobles y cuádruples | PUBLICAR POR FASCÍCULOS | Serializar la ejecución de instrucciones |
15 | pqe | Aplicación de la calidad del servicio de la plataforma | (reservado) | Híbrido | ||
dieciséis | avx512_f | Fundación AVX-512 | Paginación de 5 niveles | TSXLDTRK | TSX suspender el seguimiento de la dirección de carga | |
17 | avx512_dq | Instrucciones de AVX-512 de palabra doble y cuádruple | mawau | El valor del ajuste de ancho de dirección MPX del espacio de usuario utilizado por las instrucciones BNDLDX y BNDSTX Intel MPX en modo de 64 bits | (reservado) | |
18 | rdseed | Instrucción RDSEED | pconfig | Configuración de la plataforma (instrucciones de tecnologías de cifrado de memoria) | ||
19 | adx | Intel ADX (Extensiones de instrucciones Add-Carry de precisión múltiple) | lbr | Registros arquitectónicos de la última rama | ||
20 | golpe | Prevención de acceso al modo supervisor | cet_ibt | Seguimiento indirecto de rama de control de aplicación de flujo (CET) | ||
21 | avx512_ifma | Instrucciones de suma múltiple fusionada de enteros AVX-512 | (reservado) | |||
22 | pcommit | Instrucción PCOMMIT | rdpid | Leer ID de procesador e IA32_TSC_AUX | amx-bf16 | Cálculo de mosaicos en números bfloat16 |
23 | clflushopt | Instrucción CLFLUSHOPT | (reservado) | (reservado) | ||
24 | clwb | Instrucción CLWB | (reservado) | amx-tile | Arquitectura de azulejos | |
25 | intel_pt | Seguimiento del procesador Intel | cldemote | Degradación de línea de caché | amx-int8 | Cálculo de mosaicos en enteros de 8 bits |
26 | avx512_pf | Instrucciones de captación previa de AVX-512 | (reservado) | IBRS_IBPB / spec_ctrl | Control de la especulación, parte del control indirecto de sucursales (IBC): especulación indirecta restringida de sucursales (IBRS) y barrera de predicción indirecta de sucursales (IBPB) [21] [22] | |
27 | avx512_er | Instrucciones exponenciales y recíprocas AVX-512 | MOVDIRI | stibp | Predictor de rama indirecto de un solo hilo, parte de IBC [21] | |
28 | avx512_cd | Instrucciones de detección de conflictos AVX-512 | MOVDIR64B | L1D_FLUSH | IA32_FLUSH_CMD MSR | |
29 | sha | Extensiones Intel SHA | ENQCMD | Almacenes Enqueue | IA32_ARCH_CAPABILITIES | Mitigaciones especulativas del canal lateral [21] |
30 | avx512_bw | Instrucciones de AVX-512 Byte y Word | sgx_lc | Configuración de lanzamiento SGX | IA32_CORE_CAPABILITIES | Compatibilidad con capacidades centrales específicas del modelo de lista de MSR |
31 | avx512_vl | Extensiones de longitud de vector AVX-512 | pks | Claves de protección para páginas en modo supervisor | ssbd | Deshabilitación de la omisión de tienda especulativa, [21] como mitigación para la omisión de tienda especulativa (IA32_SPEC_CTRL) |
EAX = 7, ECX = 1: Funciones ampliadas
Esto devuelve banderas de funciones extendidas en EAX.
Un poco | EAX | |
---|---|---|
Corto | Característica | |
0 | (reservado) | |
1 | (reservado) | |
2 | (reservado) | |
3 | (reservado) | |
4 | (reservado) | |
5 | avx512_bf16 | Instrucciones AVX-512 BFLOAT16 |
6 | (reservado) | |
7 | (reservado) | |
8 | (reservado) | |
9 | (reservado) | |
10 | (reservado) | |
11 | (reservado) | |
12 | (reservado) | |
13 | (reservado) | |
14 | (reservado) | |
15 | (reservado) | |
dieciséis | (reservado) | |
17 | (reservado) | |
18 | (reservado) | |
19 | (reservado) | |
20 | (reservado) | |
21 | (reservado) | |
22 | (reservado) | |
23 | (reservado) | |
24 | (reservado) | |
25 | (reservado) | |
26 | (reservado) | |
27 | (reservado) | |
28 | (reservado) | |
29 | (reservado) | |
30 | (reservado) | |
31 | (reservado) |
EAX = 80000000h: Implementación de la función extendida más alta
El parámetro de llamada más alto se devuelve en EAX.
EAX = 80000001h: Información ampliada del procesador y bits de funciones
Esto devuelve indicadores de funciones extendidas en EDX y ECX.
Los indicadores de funciones de AMD son los siguientes: [23] [24]
Un poco | EDX | ECX | ||
---|---|---|---|---|
Corto | Característica | Corto | Característica | |
0 | fpu | FPU x87 integrado | lahf_lm | LAHF / SAHF en modo largo |
1 | vme | Extensiones de modo virtual (VIF) | cmp_legacy | Hyperthreading no es válido |
2 | Delaware | Extensiones de depuración ( CR4 bit 3) | svm | Máquina virtual segura |
3 | pse | Extensión de tamaño de página | extapic | Espacio APIC extendido |
4 | tsc | Contador de marca de tiempo | cr8_legacy | CR8 en modo de 32 bits |
5 | msr | Registros específicos del modelo | abm | Manipulación de bits avanzada ( lzcnt y popcnt ) |
6 | pae | Extensión de dirección física | sse4a | SSE4a |
7 | mce | Excepción de verificación de máquina | desalineado | Modo SSE desalineado |
8 | cx8 | Instrucción CMPXCHG8 ( comparar e intercambiar ) | 3dnowprefetch | Instrucciones de PREFETCH y PREFETCHW |
9 | apic | Controlador de interrupciones programable avanzado integrado | osvw | Solución alternativa visible del sistema operativo |
10 | (reservado) | SII | Muestreo basado en instrucciones | |
11 | syscall | Instrucciones SYSCALL y SYSRET | xop | Conjunto de instrucciones XOP |
12 | mtrr | Registros de rango de tipo de memoria | desollarlo | Instrucciones SKINIT / STGI |
13 | pge | Bit de habilitación global de página en CR4 | wdt | Temporizador de vigilancia |
14 | mca | Arquitectura de verificación de máquina | (reservado) | |
15 | cmov | Movimiento condicional e instrucciones FCMOV | lwp | Perfilado de peso ligero [25] |
dieciséis | palmadita | Tabla de atributos de página | fma4 | 4 operandos fusionados multiplicar-sumar |
17 | pse36 | Extensión de tamaño de página de 36 bits | tce | Extensión de caché de traducción |
18 | (reservado) | |||
19 | mp | Capaz de multiprocesador | nodeid_msr | NodoID MSR |
20 | nx | Bit NX | (reservado) | |
21 | (reservado) | tbm | Manipulación de bits finales | |
22 | mmxext | MMX extendido | topoext | Extensiones de topología |
23 | mmx | Instrucciones MMX | perfctr_core | Extensiones de contador de rendimiento central |
24 | fxsr | Instrucciones FXSAVE, FXRSTOR, CR4 bit 9 | perfctr_nb | Extensiones de contador de rendimiento NB |
25 | fxsr_opt | Optimizaciones FXSAVE / FXRSTOR | (reservado) | |
26 | pdpe1gb | Páginas de gigabytes | dbx | Extensiones de puntos de interrupción de datos |
27 | rdtscp | Instrucción RDTSCP | perftsc | Rendimiento TSC |
28 | (reservado) | pcx_l2i | Extensiones de contador de perfl L2I | |
29 | lm | Modo largo | (reservado) | |
30 | 3dnowext | ¡3DNow extendido! | (reservado) | |
31 | 3dnow | 3D¡Ahora! | (reservado) |
EAX = 80000002h, 80000003h, 80000004h: Cadena de marca del procesador
Estos devuelven la cadena de la marca del procesador en EAX, EBX, ECX y EDX. CPUID
debe emitirse con cada parámetro en secuencia para obtener la cadena completa de la marca del procesador ASCII terminado en nulo de 48 bytes. [26] Es necesario verificar si la característica está presente en la CPU emitiendo CPUID
con EAX = 80000000h
primero y verificando si el valor devuelto es mayor o igual a 80000004h.
#include // proporcionado por GCC#include #include int main ( void ) { uint32_t marca [ 12 ]; if ( ! __get_cpuid_max ( 0x80000004 , NULL )) { fprintf ( stderr , "Característica no implementada" ); volver 2 ; } __get_cpuid ( 0x80000002 , marca + 0x0 , marca + 0x1 , marca + 0x2 , marca + 0x3 ); __get_cpuid ( 0x80000003 , marca + 0x4 , marca + 0x5 , marca + 0x6 , marca + 0x7 ); __get_cpuid ( 0x80000004 , marca + 0x8 , marca + 0x9 , marca + 0xa , marca + 0xb ); printf ( "Marca:% s \ n " , marca ); }
EAX = 80000005h: Caché L1 e identificadores TLB
Esta función contiene la caché L1 del procesador y las características TLB.
EAX = 80000006h: Funciones de caché L2 extendidas
Devuelve detalles de la caché L2 en ECX, incluido el tamaño de la línea en bytes (Bits 07 - 00), el tipo de asociatividad (codificada por un campo de 4 bits; Bits 15 - 12) y el tamaño de la caché en KB (Bits 31 - 16) .
#include // proporcionado por GCC#include #include int main ( vacío ) { uint32_t eax , ebx , ecx , edx ; if ( __get_cpuid ( 0x80000006 , & eax , & ebx , & ecx , & edx )) { printf ( "Tamaño de línea:% d B, Tipo asociado:% d; Tamaño de caché:% d KB. \ n " , ecx & 0xff , ( ecx >> 12 ) y 0x07 , ( ecx >> 16 ) y 0xffff ); return 0 ; } else { fputs ( stderr , "La CPU no admite 0x80000006" ); volver 2 ; } }
EAX = 80000007h: información avanzada de administración de energía
Esta función proporciona identificadores avanzados de funciones de administración de energía. El bit 8 de EDX indica soporte para TSC invariante.
EAX = 80000008h: Tamaños de direcciones físicas y virtuales
Devuelve los tamaños de direcciones físicas y virtuales más grandes en EAX.
- Bits 07-00: # Bits de dirección física.
- Bits 15-8: #Bits de dirección lineal.
- Bits 31-16: Reservado = 0.
El hipervisor podría utilizarlo en un sistema de máquina virtual para informar sobre los posibles tamaños de direcciones físicas / virtuales con la CPU virtual.
EBX se utiliza para funciones:
- Bit 0: CLZERO, Borrar línea de caché con dirección en RAX.
- Bit 4: RDPRU, leer MPERF o APERF del anillo 3.
- Bit 8: MCOMMIT, confirma las tiendas en la memoria. Para cercado de memoria y recuperación de errores ECC.
- Bit 9: WBNOINVD, escribir de nuevo y no invalidar la caché.
ECX proporciona recuento de núcleos.
- Bits 07-00: # Núcleos físicos menos uno.
- Bits 11-8: Reservado = 0.
- Bits 15-12: # Bits de ID APIC. 2 elevado a esta potencia sería el recuento de núcleos físicos, siempre que no sea cero.
- Bits 17-16: Tamaño del contador de sello de tiempo de rendimiento.
- Bits 31-18: Reservado = 0.
EDX proporciona información específica para RDPRU (el identificador de registro máximo permitido) en 31-16. El número actual a partir de Zen 2 es 1 para MPERF y APERF.
EAX = 8FFFFFFFh: Huevo de Pascua de AMD
Específico para las CPU AMD K7 y K8, devuelve la cadena "IT'S HAMMER TIME" en EAX, EBX, ECX y EDX, [27] una referencia a la canción U Can't Touch This de MC Hammer .
Uso de CPUID de lenguajes de alto nivel
Ensamblaje en línea
Esta información también es de fácil acceso desde otros idiomas. Por ejemplo, el código C para gcc a continuación imprime los primeros cinco valores, devueltos por el cpuid:
#include / * Esto funciona en sistemas de 32 y 64 bits. Consulte [[Ensamblador en línea # en compiladores reales]] para obtener sugerencias sobre cómo leer este código. * / int main () { / * No es necesario inicializar los cuatro registros ya que el procesador escribirá sobre ellos. * / int infotipo , a , b , c , d ; para ( infotipo = 0 ; infotipo < 5 ; infotipo ++ ) { __asm__ ( "cpuid" : "= a" ( a ), "= b" ( b ), "= c" ( c ), "= d" ( d ) // Las variables de salida. EAX -> ay viceversa .: "0" ( infotipo )); // Ponga el infotipo en EAX. printf ( "InfoType% x \ n EAX:% x \ n EBX:% x \ n ECX:% x \ n EDX:% x \ n " , infotipo , a , b , c , d ); } return 0 ; }
En el ensamblaje en línea con sabor a compiladores de MSVC y Borland / Embarcadero C (bcc32), la información de golpe está implícita en las instrucciones:
#include int main () { unsigned int InfoType = 0 ; unsigned int a , b , c , d ; __asm { / * Realiza la llamada. * / mov EAX , InfoType ; cpuid ; / * Guardar resultados. * / mov a , EAX ; mov b , EBX ; mov c , ECX ; mov d , EDX ; } printf ( "Tipo de información% x \ n EAX:% x \ n EBX:% x \ n ECX:% x \ n EDX:% x \ n " , Tipo de información , a , b , c , d ); return 0 ; }
Si alguna de las versiones se escribió en lenguaje ensamblador simple, el programador debe guardar manualmente los resultados de EAX, EBX, ECX y EDX en otro lugar si desea seguir usando los valores.
Funciones de envoltura
GCC también proporciona un encabezado llamado
en sistemas que tienen CPUID. El __cpuid
es una macro expansión a inline montaje. El uso típico sería:
#include #include int main ( vacío ) { int a , b , c , d ; __cpuid ( 0 / * cadena de proveedor * / , a , b , c , d ); printf ( "EAX:% x \ n EBX:% x \ n ECX:% x \ n EDX:% x \ n " , a , b , c , d ); return 0 ; }
Pero si uno solicita una función extendida que no está presente en esta CPU, no se daría cuenta y podría obtener resultados aleatorios e inesperados. También se proporciona una versión más segura en
. Comprueba las funciones ampliadas y realiza más comprobaciones de seguridad. Los valores de salida no se pasan utilizando macroparámetros de referencia, sino punteros más convencionales.
#include #include int main ( vacío ) { int a , b , c , d ; if ( ! __get_cpuid ( 0x81234567 / * inexistente, pero supongamos que existe * / , & a , & b , & c , & d )) { fprintf ( stderr , "Advertencia: la solicitud de CPUID 0x81234567 no es válida! \ n " ); } printf ( "EAX:% x \ n EBX:% x \ n ECX:% x \ n EDX:% x \ n " , a , b , c , d ); return 0 ; }
Observe los símbolos &a, &b, &c, &d
y la declaración condicional. Si la __get_cpuid
llamada recibe una solicitud correcta, devolverá un valor distinto de cero, si falla, cero. [28]
El compilador de Microsoft Visual C tiene una función incorporada, __cpuid()
por lo que la instrucción cpuid se puede incrustar sin usar el ensamblaje en línea, lo cual es útil ya que la versión x86-64 de MSVC no permite el ensamblaje en línea en absoluto. El mismo programa para MSVC sería:
#include #include int main () { int cpuInfo [ 4 ]; para ( int a = 0 ; a < 5 ; a ++ ) { __cpuid ( cpuInfo , a ); std :: cout << "El código" << a << "da" << cpuInfo [ 0 ] << "," << cpuInfo [ 1 ] << "," << cpuInfo [ 2 ] << ", " << cpuInfo [ 3 ] << '\ n' ; } return 0 ; }
Muchos lenguajes de secuencias de comandos interpretados o compilados pueden utilizar CPUID a través de una biblioteca FFI . Una de estas implementaciones muestra el uso del módulo Ruby FFI para ejecutar lenguaje ensamblador que incluye el código de operación CPUID.
Información específica de la CPU fuera de x86
Algunas de las arquitecturas de CPU que no son x86 también proporcionan ciertas formas de información estructurada sobre las capacidades del procesador, comúnmente como un conjunto de registros especiales:
- Las arquitecturas ARM tienen un
CPUID
registro de coprocesador que requiere EL1 o superior para acceder. [29] - Los procesadores de mainframe IBM System z tienen una instrucción Store CPU ID (
STIDP
) desde 1983 IBM 4381 [30] para consultar el ID del procesador. [31] - Los procesadores de mainframe IBM System z también tienen una instrucción Store Facilities List Extended (
STFLE
) que enumera las características de hardware instaladas. [31] - La arquitectura MIPS32 / 64 define una identificación de procesador obligatoria (
PrId
) y una serie de registros de configuración en cadena . [32] - El procesador PowerPC tiene el registro de versión del procesador de solo lectura de 32 bits (
PVR
) que identifica el modelo de procesador en uso. La instrucción requiere nivel de acceso de supervisor. [33]
Las familias de chips DSP y tipo transputer no han tomado la instrucción de ninguna manera notable, a pesar de tener (en términos relativos) tantas variaciones en el diseño. Pueden estar presentes formas alternativas de identificación de silicio; Por ejemplo, los DSP de Texas Instruments contienen un conjunto de registros basado en memoria para cada unidad funcional que comienza con identificadores que determinan el tipo y modelo de unidad, su revisión de diseño ASIC y características seleccionadas en la fase de diseño, y continúa con datos y control específicos de la unidad. registros. El acceso a estas áreas se realiza simplemente usando las instrucciones de carga y almacenamiento existentes; por tanto, para tales dispositivos no hay necesidad de extender el conjunto de registros para los propósitos de identificación del dispositivo. [ cita requerida ]
Ver también
- CPU-Z , una utilidad de Windows que se utiliza
CPUID
para identificar varias configuraciones del sistema - Spectre (vulnerabilidad de seguridad)
- Bypass de tienda especulativa (SSB)
- / proc / cpuinfo , un archivo de texto generado por ciertos sistemas que contiene parte de la información de CPUID
Referencias
- ^ "Manual del desarrollador de software de arquitecturas Intel 64 e IA-32" (PDF) . Intel.com . Consultado el 11 de abril de 2013 .
- ^ "Detectando procesadores Intel - Conociendo la generación de una CPU del sistema" . Rcollins.org . Consultado el 11 de abril de 2013 .
- ^ "LXR linux-old / arch / i386 / kernel / head.S" . Lxr.linux.no. Archivado desde el original el 13 de julio de 2012 . Consultado el 11 de abril de 2013 .
- ^ "CPUID, EAX = 4 - Resultados extraños (resuelto)" . Software.intel.com . Consultado el 10 de julio de 2014 .
- ^ "instrucción CPUID ao486" .
- ^ "Softcore compatible con v586: 586 para FPGA" .
- ^ https://cpufun.substack.com/p/fun-with-timers-and-cpuid
- ^ "Capítulo 3 Referencia de conjunto de instrucciones, AL" (PDF) . Manual del desarrollador de software de arquitecturas Intel® 64 e IA-32 . Corporación Intel. 2018-12-20 . Consultado el 20 de diciembre de 2018 .
- ^ http://bochs.sourceforge.net/techspec/24161821.pdf
- ^ Huggahalli, Ram; Iyer, Ravi; Tetrick, Scott (2005). "Acceso directo a la caché para E / S de red de gran ancho de banda". ACM SIGARCH Computer Architecture News . 33 (2): 50–59. doi : 10.1145 / 1080695.1069976 . CiteSeerX : 10.1.1.91.957 .
- ^ Drepper, Ulrich (2007), Lo que todo programador debe saber sobre la memoria , CiteSeerX : 10.1.1.91.957
- ^ "Mecanismos para determinar si el software se está ejecutando en una máquina virtual VMware" . Base de conocimientos de VMware . VMWare . 2015-05-01.
Las CPU de Intel y AMD han reservado el bit 31 de ECX de la hoja de CPUID 0x1 como bit de presencia del hipervisor. Este bit permite que los hipervisores indiquen su presencia al sistema operativo invitado. Los hipervisores establecen este bit y las CPU físicas (todas las CPU existentes y futuras) establecen este bit en cero. Los sistemas operativos invitados pueden probar el bit 31 para detectar si se están ejecutando dentro de una máquina virtual.
- ^ Kataria, Alok; Hecht, Dan (1 de octubre de 2008). "Propuesta de interfaz CPUID de hipervisor" . Archivo LKML en lore.kernel.org. Archivado desde el original el 15 de marzo de 2019.
Bit 31 de ECX de CPUID hoja 0x1. Este bit ha sido reservado por Intel y AMD para su uso por hipervisores e indica la presencia de un hipervisor. Las CPU virtuales (hipervisores) establecen este bit en 1 y las CPU físicas (todas las CPU existentes y futuras) establecen este bit en cero. El software invitado puede probar este bit para detectar si se están ejecutando dentro de una máquina virtual.
- ^ a b Shih Kuo (27 de enero de 2012). "Enumeración de topología de procesador de arquitectura Intel® 64" .
- ^ "Procesador y enumeración de núcleos mediante CPUID | AMD" . Developer.amd.com. Archivado desde el original el 14 de julio de 2014 . Consultado el 10 de julio de 2014 .
- ^ "¿Los procesadores Sandybridge informan un número de núcleo incorrecto?" . Software.intel.com. 2012-12-29 . Consultado el 10 de julio de 2014 .
- ^ "cpuid, __cpuidex" . Msdn.microsoft.com. 2014-06-20 . Consultado el 10 de julio de 2014 .
- ^ "Arquitectura x86 - CPUID" . sandpile.org . Consultado el 10 de julio de 2014 .
- ^ "topology.cpp en ps / trunk / source / lib / sysdep / arch / x86_x64 - Wildfire Games" . Trac.wildfiregames.com. 2011-12-27 . Consultado el 10 de julio de 2014 .
- ^ Tecnología Hyper-Threading y detección de procesadores multinúcleo
- ^ a b c d "Mitigaciones de canal lateral de ejecución especulativa" (PDF) . Revisión 2.0. Intel . Mayo de 2018 [enero de 2018]. Número de documento: 336996-002 . Consultado el 26 de mayo de 2018 .
- ^ "Serie de parches IBRS [LWN.net]" .
- ^ CPUID especificación (PDF) , AMD , septiembre de 2010 , recuperada 02/04/2013
- ^ Código fuente del kernel de Linux
- ^ Ligera perfiles especificación (PDF) , AMD , August 2010 , recuperada 03/04/2013
- ^ "Identificación del procesador Intel® y la instrucción CPUID" (PDF) . Download.intel.com. 2012-03-06 . Consultado el 11 de abril de 2013 .
- ^ Ferrie, Peter. "Ataques a emuladores de máquinas virtuales" (PDF) . symantec.com . Investigación avanzada de amenazas de Symantec. Archivado desde el original (PDF) el 2007-02-07 . Consultado el 15 de marzo de 2017 .
- ^ https://github.com/gcc-mirror/gcc/blob/master/gcc/config/i386/cpuid.h
- ^ "Centro de información ARM" . Infocenter.arm.com . Consultado el 11 de abril de 2013 .
- ^ "Códigos de versión del procesador y constantes SRM" . Archivado desde el original el 8 de septiembre de 2014 . Consultado el 8 de septiembre de 2014 .
- ^ a b "Guía técnica de IBM System z10 Enterprise Class" (PDF) .
- ^ "Arquitectura MIPS32 para programadores, volumen III: la arquitectura de recursos privilegiados MIPS32" (PDF) . MIPS Technologies, Inc. 12 de marzo de 2001.
- ^ "Arquitectura del entorno operativo de PowerPC, libro III" (PDF) .
Otras lecturas
- "Extensión de control indirecto de sucursales de la tecnología AMD64" (PDF) (Informe técnico). Revisión 4.10.18. Advanced Micro Devices, Inc. (AMD). 2018. Archivado (PDF) desde el original el 9 de mayo de 2018 . Consultado el 9 de mayo de 2018 .
enlaces externos
- Identificación del procesador Intel y la instrucción CPUID (Nota de aplicación 485), última versión publicada. Se dice que se incorporó al Manual del desarrollador de software de arquitecturas Intel® 64 e IA-32 en 2013 , pero a partir de julio de 2014[actualizar] el manual todavía dirige al lector a la nota 485.
- Sin embargo, contiene información que puede ser y fue fácilmente malinterpretada, particularmente con respecto a la identificación de la topología del procesador .
- Los grandes manuales de Intel tienden a quedarse atrás del documento Intel ISA, disponible en la parte superior de esta página , que se actualiza incluso para procesadores que aún no están disponibles públicamente y, por lo tanto, generalmente contiene más bits de CPUID. Por ejemplo, al momento de escribir este artículo, el libro ISA (en la revisión 19, con fecha de mayo de 2014) documenta el bit CLFLUSHOPT en la hoja 7, pero los grandes manuales, aunque aparentemente más actualizados (en la revisión 51, con fecha de junio de 2014) no No lo menciono.
- Manual del programador de la arquitectura AMD64 Volumen 3: Instrucciones de uso general y del sistema
- cpuid.exe, una herramienta de línea de comandos de código abierto para Windows, disponible en SysTools.zip . Ejemplo : cpuid -v muestra el valor de cada marca de característica de CPUID.
- instlatx64 : colección de volcados de latencia de instrucción, latencia de memoria y CPUID x86 / x64