From WikiChip
Editing centaur/microarchitectures/cha
Warning: You are not logged in. Your IP address will be publicly visible if you make any edits. If you log in or create an account, your edits will be attributed to your username, along with other benefits.
The edit can be undone.
Please check the comparison below to verify that this is what you want to do, and then save the changes below to finish undoing the edit.
This page supports semantic in-text annotations (e.g. "[[Is specified as::World Heritage Site]]") to build structured and queryable content provided by Semantic MediaWiki. For a comprehensive description on how to use annotations or the #ask parser function, please have a look at the getting started, in-text annotation, or inline queries help pages.
Latest revision | Your text | ||
Line 12: | Line 12: | ||
|speculative=Yes | |speculative=Yes | ||
|renaming=Yes | |renaming=Yes | ||
− | |||
− | |||
|decode=4-way | |decode=4-way | ||
|isa=x86-64 | |isa=x86-64 | ||
Line 43: | Line 41: | ||
}} | }} | ||
'''CHA''' is a [[16-nanometer]] [[x86]] SoC microarchitecture designed by [[Centaur Technology]] for the server market. | '''CHA''' is a [[16-nanometer]] [[x86]] SoC microarchitecture designed by [[Centaur Technology]] for the server market. | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
== Process technology == | == Process technology == | ||
− | + | {{empty section}} | |
− | |||
− | |||
− | { | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
== Architecture == | == Architecture == | ||
Line 86: | Line 55: | ||
==== NCORE NPU ==== | ==== NCORE NPU ==== | ||
− | :[[File:ncore block diagram.svg| | + | :[[File:ncore block diagram.svg|700px]] |
=== Memory Hierarchy === | === Memory Hierarchy === | ||
Line 117: | Line 86: | ||
*** 4 Channels | *** 4 Channels | ||
**** DDR4, up to 3,200 MT/s | **** DDR4, up to 3,200 MT/s | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
== Overview == | == Overview == | ||
[[File:cha soc overview.svg|thumb|right|CHA Overview]] | [[File:cha soc overview.svg|thumb|right|CHA Overview]] | ||
− | Announced in 2019 and expected to be introduced in 2020, | + | Announced in 2019 and expected to be introduced in 2020, CHA is an [[x86]] SoC designed by [[Centaur]] for the server, edge, and AI market. Fabricated on TSMC [[16 nm process]], the chip integrates eight high-performance [[x86]] "CNS" cores along with a high-performance "NCORE" [[neural processor]]. This is the first server x86 chip to integrate an AI [[accelerator]]. The integrated NPU is designed to allow for a reduction of platform cost by offering an AI inference coprocessor "free" on-die along with the standard server-class x86 cores. For many workloads, this accelerator means it's no longer required to add a third-party PCIe-based [[accelerator card]] unless a considerably higher performance is required. |
− | + | The CHA SoC features new CNS cores which introduce considerably higher [[single-thread performance]]. The cores also introduce the {{x86|AVX-512}} extension in order to offer better performance and more flexibility. | |
+ | |||
+ | The CHA SoC incorporates both the [[source bridge]] and [[north bridge]] on-die. The chip supports for up to quad-channel [[DDR4 memory]] and up to 44 PCIe Gen 3 lanes. Additionally, CHA supports the ability to directly link to a second CHA SoC in a 2-way [[multiprocessing]] configuration. All the cores, along with the NCORE, the southbridge, and memory controller are all [[ring interconnect|interconnected on a ring]]. | ||
== CNS Core == | == CNS Core == | ||
− | CNS is the x86 core integrated into CHA. This is a 4-way wide front-end | + | CNS is the x86 core integrated into CHA. This is a 4-way wide front-end out-of-order pipeline with an eight-wide back-end. |
=== Front-end === | === Front-end === | ||
Line 162: | Line 102: | ||
==== Fetch and decode ==== | ==== Fetch and decode ==== | ||
− | + | CNS has a 32 KiB [[L1 instruction cache]] organized as 8 ways of 64 sets. Each cycle, up to 32 bytes of the instruction stream are fetched from the [[instruction cache]] into the formatted instruction queue (FIQ). Here, the byte array is formatted into the individual instructions before getting sent to the [[instruction decode|decode]]. Additionally, the FIQ has the ability to do [[macro-fusion]]. CNS can detect certain pairs of adjacent instructions such as a simple arithmetic operation followed by a conditional jump and couple them together such that they get decoded at the same time into a fused operation. This was improved further with the new CNS core. | |
− | CNS has a 32 KiB [[L1 instruction cache]] organized as 8 ways of 64 sets. | ||
− | + | From the FIQ, up to four instructions (or five if fused) are sent to the decode. CNS features four homogenous decoders - each capable of decoding all types of instructions. For fused instructions, those instructions are decoded into a fused micro-operations which remain fuse for its remaining lifetime. In other words, those fused instructions will retire as a fused instruction. This enables CNS to decode up to five instructions per cycle, reducing the effective bandwidth across the entire pipeline from the fused operations. | |
− | |||
− | |||
− | |||
− | |||
− | From the FIQ, up to four instructions (or five if fused) are sent to the decode. CNS features four homogenous decoders - each capable of decoding all types of instructions | ||
Following decode, instructions are queued up in the micro-operation queue which serves to decouple the front-end from the back-end. | Following decode, instructions are queued up in the micro-operation queue which serves to decouple the front-end from the back-end. | ||
=== Back-end === | === Back-end === | ||
− | The back-end deals with the [[out-of-order]] execution of instructions. CNS | + | The back-end deals with the [[out-of-order]] execution of instructions. CNS makes major improvements to the back-end over prior generations. From the front-end, micro-operations are fetched from the micro-operation queue which decouples the front-end from the back-end. Each cycle, up to four instructions can be renamed (and later retire). This is an increase from the previously 3-wide [[instruction rename|rename]]. The widening of rename and retire matches the decode rate of the front-end. |
− | Prior Centaur chips were manufactured on relatively older [[process nodes]] such as [[65 nm]] and later [[45 nm]]. The move to a more leading-edge node ([[TSMC]] [[16-nanometer]] [[FinFET]], in this case) provided them with a significantly higher transistor budget. Centaur takes advantage of that to build a wider out-of-order core. To that end, | + | Prior Centaur chips were manufactured on relatively older [[process nodes]] such as [[65 nm]] and later [[45 nm]]. The move to a more leading-edge node ([[TSMC]] [[16-nanometer]] [[FinFET]], in this case) provided them with a significantly higher transistor budget. Centaur takes advantage of that to build a wider out-of-order core. To that end, Centaur’s CNS core supports 192 OoO instructions in-flight. This is identical to both {{intel|Haswell|Intel Haswell|l=arch}} and {{amd|Zen|AMD Zen|l=arch}}. |
==== Execution ports ==== | ==== Execution ports ==== | ||
Line 186: | Line 120: | ||
===== Floating Point & Vector ===== | ===== Floating Point & Vector ===== | ||
− | CNS incorporates three dedicated ports for [[floating-point]] and vector operations. Two of the ports support [[fused-multiply-add|FMA operations]] while the third has the divide and crypto units. All three pipes are 256-bit wide. In terms of raw compute power, the total [[FLOPS]] per core is 16 double-precision FLOPs/cycle – reaching parity with AMD {{amd|Zen 2|l=arch}} as well as Intel's {{intel| | + | CNS incorporates three dedicated ports for [[floating-point]] and vector operations. Two of the ports support [[fused-multiply-add|FMA operations]] while the third has the divide and crypto units. All three pipes are 256-bit wide. In terms of raw compute power, the total [[FLOPS]] per core is 16 double-precision FLOPs/cycle – reaching parity with AMD {{amd|Zen 2|l=arch}} as well as Intel's {{intel|Haswelll=arch}}, {{intel|Broadwell|l=arch}}, and {{intel|Skylake (Client)|l=arch}}. |
− | CNS added extensive [[x86]] ISA support, including new support for {{x86|AVX-512}}. CNS supports all the AVX-512 extensions supported by Intel's {{intel|Skylake (Server)|l=arch}} as well as those found in {{intel|Palm Cove|l=arch}}. From an implementation point of view, | + | CNS added extensive [[x86]] ISA support, including new support for {{x86|AVX-512}}. CNS supports all the AVX-512 extensions supported by Intel's {{intel|Skylake (Server)|l=arch}} as well as those found in {{intel|Palm Cove|l=arch}}. From an implementation point of view, Centaur’s CNS cores Vector lanes are 256-wide, therefore AVX-512 operations are cracked into two 256-wide operations which are then scheduled independently. In other words, there is no throughput advantage here. The design is similar to how AMD dealt with AVX-256 in their {{amd|Zen core|l=arch}} where operations had to be executed as two 128-bit wide operations. Note that the implementation of AVX-512 on CNS usually exhibits no downclocking. The design of the core was such that it's designed to operate at the full frequency of the core and the rest of the SoC. Centaur does implement a power management engine that's capable of downclocking for certain power-sensitive SKUs if necessary. |
=== Memory subsystem === | === Memory subsystem === | ||
− | + | The memory subsystem on CNS features three ports - two generic AGUs and one store AGU port. CNS supports 116 memory operations in-flight. The MOB consists of a 72-entry load-buffer and a 44-entry store buffer. | |
− | The memory subsystem on CNS features three ports - two generic AGUs and one store AGU port | ||
− | |||
− | |||
− | + | CNS features a [[level 1 data cache]] with a capacity of 32 KiB. The cache is organized as 8 ways of 64 sets. It is fully multi-ported, supporting 2 reads and 1 write every cycle. Each port is 32B wide, therefore 512-bit memory operations, like the arithmetic counterparts, have to be cracked into two 256-bit operations. With two load operations, CNS can do a single 512-bit operation each cycle. | |
== NCORE NPU == | == NCORE NPU == | ||
− | The [[neural processor|AI accelerator coprocessor]] sits on the same ring as the rest of the chip with its own dedicated ring stop. NCORE has two DMA channels, | + | The [[neural processor|AI accelerator coprocessor]] sits on the same ring as the rest of the chip with its own dedicated ring stop. NCORE has two DMA channels, capable of reading and writing to/from the L3 cache slices, DRAM, and in theory also I/O. NCORE has a relatively different architecture to many of the dedicated [[neural processors]] developed by various startups. To that end, NCORE is an extremely-wide 32,768-bit [[VLIW]] [[SIMD]] [[coprocessor]]. The coprocessor is a programmable coprocessor that's capable of controlling up to 4K-lanes of logic each cycle at the same clock frequency as the CPU cores. 4K bytes operations are available every cycle and since the NCORE is directly connected to the ring, latency is extremely low compared to externally-attached accelerators. |
− | + | Instructions are brought to the NCORE through the ring and are stored in a centralized instruction unit. The unit incorporates a 12 KiB instruction cache and a 4 KiB instruction ROM. Each cycle, a single 128-bit instruction is fetched, decoded, and gets executed by a sequencer which controls simultaneously all the compute slices and memory. The instruction ROM is used for executing validation code as well as commonly-used functions. The instruction sequencer incorporates a loop counter and various special registers along with sixteen address registers and dedicated hardware for performing on various addressing modes and auto-incrementation operations. The entire NCORE datapath is 4,096-byte wide. | |
− | Data to the NCORE are fed into the NCORE caches. Data is fed by the two DMA channels on the ring stop interface. These DMA channels can go out to the other caches or memory asynchronously. On occasion, data may be fed from the device driver or software running on one of the CPU cores which can move instructions and data into the NCORE RAM. The NCORE features a very large and very fast | + | Data to the NCORE are fed into the NCORE caches. Data is fed by the two DMA channels on the ring stop interface. These DMA channels can go out to the other caches or memory asynchronously. On occasion, data may be fed from the device driver or software running on one of the CPU cores which can move instructions and data into the NCORE RAM. The NCORE features a very large and very fast 16 MiB SRAM cache. The cache comprises two SRAM banks - D-RAM and W-RAM - each one is 4,096-bytes wide and is 64-bit ECC-protected. The two SRAMs operate at the same clock as the NCORE itself which is the same clock as the CPU cores. Each cycle, up to two reads (one form each bank) can be done. With each one being 4,096-byte interface, each cycle up to 8,192-bytes can be read into the compute interface. This enables the NCORE to have a theoretical peak read bandwidth of 20.5 TB/s. It's worth noting that physically, the NCORE is built up using small compute units called "slices" or "neurons". The design is done in this way in order to allow for future reconfigurability. The full CHA configuration features 16 slices. Each slice is a 256-byte wide SIMD unit and is accompanied by its own 2,048 256B-wide rows cache slice. |
:[[File:ncore slices.svg|800px]] | :[[File:ncore slices.svg|800px]] | ||
− | + | ||
[[File:cha ncore.svg|thumb|right|300px|NCORE Pipeline]] | [[File:cha ncore.svg|thumb|right|300px|NCORE Pipeline]] | ||
− | + | The compute interface passes the data from the RAMs to the neural data unit. The neural data unit operates on incoming data on each clock before it goes to the SIMD processing unit. The purpose of the data unit is to simply prepare data for the neural processing unit by doing various pre-processing. The data unit has a four-entry 4K register file which can also serve as inputs for various operations and has output to the next stage in the pipeline. The data unit can do operations such as rotate on the entire 4K-byte line, broadcast (taking one byte from each 64B-slice and expend it into 64 bytes for replication used in weight structuring for convolutions), merge from two inputs (e.g., RAM and register), compress data (for pooling operations), and various other specialized functions. | |
− | |||
− | |||
− | The compute interface passes the data from the RAMs to the neural data unit | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | + | Each cycle, the neural processing unit reads data out of one or two of the four registers in the neural data unit. The neural processing unit does various computations such as MAC operations, shifting, min/max, and various other functions designed to add flexibility in terms of support in preparation for future AI functionalities and operations. The neural processing unit incorporates a 32-bit 4K accumulator which can operate in both 32b-integer and 32b-[[floating-point]] modes. The accumulator saturates on overflows to prevent wrap-around (e.g., the biggest positive to biggest negative). Following the millions or billions of repeated MAC operations, the output is sent to the output unit for post-processing. | |
− | |||
− | The output unit incorporates various other less common functionalities that run at a slightly slower rate than 4K/clock. | + | Data from the neural processing unit is sent to the output unit for post-processing. Here the unit incorporates an activation unit which can perform the standard activation functions such as [[sigmoid]], [[hyperbolic tangent|TanH]], [[rectified linear unit|ReLu]], and others. Additionally, the output unit can perform data compression and quantization to be used in the next convolution. The output unit incorporates various other less common functionalities that run at a slightly slower rate than 4K/clock. Finally, data is written back to one of the memory banks each cycle. |
On various rare occasions, some functionality might not be possible on the NCORE (e.g., an operation that's done once an image). Here, the core can use the standard x86 core to do such operations. Centaur's device driver manages the runtime stack which is capable of feeding the NCORE with NCORE instructions and operations and the x86 core with various other subroutines to execute when necessary which can take advantage of the {{x86|AVX-512}} support to accelerate various operations. | On various rare occasions, some functionality might not be possible on the NCORE (e.g., an operation that's done once an image). Here, the core can use the standard x86 core to do such operations. Centaur's device driver manages the runtime stack which is capable of feeding the NCORE with NCORE instructions and operations and the x86 core with various other subroutines to execute when necessary which can take advantage of the {{x86|AVX-512}} support to accelerate various operations. | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
== Ring == | == Ring == | ||
Line 259: | Line 162: | ||
== Die == | == Die == | ||
=== SoC === | === SoC === | ||
− | * [[TSMC]] [[16 nm process]] | + | * [[TSMC]] [[16 nm process]] |
* 194 mm² | * 194 mm² | ||
− | :[[File: | + | :[[File:cha soc.png|600px]] |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
=== Core group === | === Core group === | ||
− | + | :[[File:cha core group.png|500px]] | |
− | |||
− | |||
− | |||
− | |||
− | :[[File:cha core group.png| | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
=== NCORE === | === NCORE === | ||
Line 294: | Line 178: | ||
<div style="float: left;">[[File:cha soc ncore.png|300px]]</div> | <div style="float: left;">[[File:cha soc ncore.png|300px]]</div> | ||
<div style="float: left;">[[File:cha soc ncore (2).png|300px]]</div> | <div style="float: left;">[[File:cha soc ncore (2).png|300px]]</div> | ||
− | |||
</div> | </div> | ||
{{clear}} | {{clear}} | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
== Bibliography == | == Bibliography == | ||
* {{bib|personal|November 2019|Centaur}} | * {{bib|personal|November 2019|Centaur}} | ||
− | |||
== See also == | == See also == |
Facts about "CHA - Microarchitectures - Centaur Technology"
codename | CHA + |
core count | 8 + |
designer | Centaur Technology + |
full page name | centaur/microarchitectures/cha + |
instance of | microarchitecture + |
instruction set architecture | x86-64 + |
manufacturer | TSMC + |
microarchitecture type | CPU + |
name | CHA + |
pipeline stages (max) | 22 + |
pipeline stages (min) | 20 + |
process | 16 nm (0.016 μm, 1.6e-5 mm) + |