Microoperación

En las unidades centrales de procesamiento de computadoras , las microoperaciones (también conocidas como micro-ops o μops , históricamente también como microacciones ^{[ 2 ]} ) son instrucciones detalladas de bajo nivel que se utilizan en algunos diseños para implementar instrucciones de máquina complejas (a veces denominadas macro-instrucciones en este contexto). ^{[ 3 ] : 8–9}

Generalmente, las microoperaciones realizan operaciones básicas sobre los datos almacenados en uno o más registros , incluyendo la transferencia de datos entre registros o entre registros y buses externos de la unidad central de procesamiento (CPU), y la realización de operaciones aritméticas o lógicas sobre los registros. Las microoperaciones se suelen representar mediante el lenguaje de transferencia de registros . ^{[ 4 ]} En un ciclo típico de búsqueda, decodificación y ejecución , cada paso de una macroinstrucción se descompone durante su ejecución, de modo que la CPU determina y ejecuta una serie de microoperaciones. La ejecución de las microoperaciones se realiza bajo el control de la unidad de control de la CPU , que decide sobre su ejecución mientras realiza diversas optimizaciones como la reordenación, la fusión y el almacenamiento en caché. ^{[ 1 ]}

Diversas formas de microoperaciones (μops) han sido durante mucho tiempo la base de las rutinas de microcódigo tradicionales utilizadas para simplificar la implementación de un diseño de CPU particular o, quizás, simplemente la secuenciación de ciertas operaciones de varios pasos o modos de direccionamiento. Más recientemente, las μops también se han empleado de una manera diferente para permitir que los procesadores CISC modernos manejen más fácilmente la ejecución asíncrona paralela y especulativa: al igual que con el microcódigo tradicional, se realiza una o más búsquedas en tablas (o equivalente) para localizar la secuencia de μop apropiada según la codificación y la semántica de la instrucción de máquina (el paso de decodificación o traducción); sin embargo, en lugar de tener secuencias de μops rígidas que controlan la CPU directamente desde una ROM de microcódigo , las μops se almacenan dinámicamente en búfer para su reprogramación antes de su ejecución. ^{[ 5 ] : 6–7, 9–11}

This buffering means that the fetch and decode stages can be more detached from the execution units than is feasible in a more traditional microcoded (or hard-wired) design. As this allows a degree of freedom regarding execution order, it makes some extraction of instruction-level parallelism out of a normal single-threaded program possible (provided that dependencies are checked, etc.). It opens up for more analysis and therefore also for reordering of code sequences in order to dynamically optimize mapping and scheduling of μops onto machine resources (such as ALUs, load/store units, etc.). As this happens on the μop-level, sub-operations of different machine (macro) instructions may often intermix in a particular μop-sequence, forming partially reordered machine instructions as a direct consequence of the out-of-order dispatching of microinstructions from several macro instructions. However, this is not the same as the micro-op fusion, which aims at the fact that a more complex microinstruction may replace a few simpler microinstructions in certain cases, typically in order to minimize state changes and usage of the queue and re-order buffer space, therefore reducing power consumption. Micro-op fusion is used in some modern CPU designs.^{[3]:89–91,105–106[5]:6–7,9–15}

Execution optimization has gone even further; processors not only translate many machine instructions into a series of μops, but also do the opposite when appropriate; they combine certain machine instruction sequences (such as a compare followed by a conditional jump) into a more complex μop which fits the execution model better and thus can be executed faster or with less machine resources involved. This is also known as macro-op fusion.^{[3]:106–107[5]:12–13}

Another way to try to improve performance is to cache the decoded micro-operations in a micro-operation cache, so that if the same macroinstruction is executed again, the processor can directly access the decoded micro-operations from the cache, instead of decoding them again. The execution trace cache found in IntelNetBurst microarchitecture (Pentium 4) is a widespread example of this technique.^[6] The size of this cache may be stated in terms of how many thousands (or strictly multiple of 1024) of micro-operations it can store: Kμops.^[7]