从前，在写x86汇编语言时，例如，你需要指令说明“将EDX寄存器加载为值5”，“增加EDX”寄存器等。
对于现代拥有4个核心（甚至更多）的CPU，在机器代码级别上是否看起来就像有4个单独的CPU（即是否只有4个不同的“EDX”寄存器）？如果是这样，当你说“增加EDX寄存器”时，是什么决定了哪个CPU的EDX寄存器被增加？在x86汇编中现在是否有“CPU上下文”或“线程”概念？
多核心之间的通信/同步是如何工作的？
如果您要编写操作系统，硬件公开了哪种机制可以允许您在不同的核心上调度执行？这是一些特殊的特权指令吗？
如果您要为多核心CPU编写优化编译器/字节码VM，那么您需要特别了解，比如x86，以使其生成在所有核心上高效运行的代码？
x86机器代码已经做出哪些改变以支持多核功能？
mov edx, 0
只会更新EDX当前运行的线程。没有办法使用单个汇编指令修改另一个处理器上的EDX。您需要某种系统调用来请求操作系统告知另一个线程运行代码以更新其自己的EDX。
带有所有必需样板的可运行裸机示例。下面涵盖了所有主要部分。
在Ubuntu 15.10 QEMU 2.3.0和Lenovo ThinkPad T400 真实硬件客户端上测试通过。
Intel手册第3卷系统编程指南-325384-056US September 2015在第8、9和10章中涵盖了SMP。
表8-1.“广播INIT-SIPI-SIPI序列和超时选择”包含一个基本可行的示例：
MOV ESI, ICR_LOW ; Load address of ICR low dword into ESI.
MOV EAX, 000C4500H ; Load ICR encoding for broadcast INIT IPI
; to all APs into EAX.
MOV [ESI], EAX ; Broadcast INIT IPI to all APs
; 10-millisecond delay loop.
MOV EAX, 000C46XXH ; Load ICR encoding for broadcast SIPI IP
; to all APs into EAX, where xx is the vector computed in step 10.
MOV [ESI], EAX ; Broadcast SIPI IPI to all APs
; 200-microsecond delay loop
MOV [ESI], EAX ; Broadcast second SIPI IPI to all APs
; Waits for the timer interrupt until the timer expires
Most operating systems will make most of those operations impossible from ring 3 (user programs).
So you need to write your own kernel to play freely with it: a userland Linux program will not work.
At first, a single processor runs, called the bootstrap processor (BSP).
It must wake up the other ones (called Application Processors (AP)) through special interrupts called Inter Processor Interrupts (IPI).
Those interrupts can be done by programming Advanced Programmable Interrupt Controller (APIC) through the Interrupt command register (ICR)
The format of the ICR is documented at: 10.6 "ISSUING INTERPROCESSOR INTERRUPTS"
The IPI happens as soon as we write to the ICR.
ICR_LOW is defined at 8.4.4 "MP Initialization Example" as:
ICR_LOW EQU 0FEE00300H
The magic value 0FEE00300 is the memory address of the ICR, as documented at Table 10-1 "Local APIC Register Address Map"
The simplest possible method is used in the example: it sets up the ICR to send broadcast IPIs which are delivered to all other processors except the current one.
But it is also possible, and recommended by some, to get information about the processors through special data structures setup by the BIOS like ACPI tables or Intel's MP configuration table and only wake up the ones you need one by one.
XX in 000C46XXH encodes the address of the first instruction that the processor will execute as:
CS = XX * 0x100
IP = 0
Remember that CS multiples addresses by 0x10, so the actual memory address of the first instruction is:
XX * 0x1000
So if for example XX == 1, the processor will start at 0x1000.
We must then ensure that there is 16-bit real mode code to be run at that memory location, e.g. with:
cld
mov $init_len, %ecx
mov $init, %esi
mov 0x1000, %edi
rep movsb
.code16
init:
xor %ax, %ax
mov %ax, %ds
/* Do stuff. */
hlt
.equ init_len, . - init
Using a linker script is another possibility.
The delay loops are an annoying part to get working: there is no super simple way to do such sleeps precisely.
Possible methods include:
Related: How to display a number on the screen and and sleep for one second with DOS x86 assembly?
I think the initial processor needs to be in protected mode for this to work as we write to address 0FEE00300H which is too high for 16-bits
To communicate between processors, we can use a spinlock on the main process, and modify the lock from the second core.
We should ensure that memory write back is done, e.g. through wbinvd.
8.7.1章节“逻辑处理器的状态”中提到：
以下功能是Intel 64或IA-32处理器内逻辑处理器的架构状态的一部分，支持Intel Hyper-Threading技术。这些功能可以分为三组：缓存共享讨论在以下链接中：
Intel 超线程比独立核心具有更大的缓存和流水线共享：https://superuser.com/questions/133082/hyper-threading-and-dual-core-whats-the-difference/995858#995858
主要初始化动作似乎在 arch/x86/kernel/smpboot.c 中。
这里提供一个最小的可运行的ARMv8 aarch64示例，适用于QEMU：
.global mystart
mystart:
/* Reset spinlock. */
mov x0, #0
ldr x1, =spinlock
str x0, [x1]
/* Read cpu id into x1.
* TODO: cores beyond 4th?
* Mnemonic: Main Processor ID Register
*/
mrs x1, mpidr_el1
ands x1, x1, 3
beq cpu0_only
cpu1_only:
/* Only CPU 1 reaches this point and sets the spinlock. */
mov x0, 1
ldr x1, =spinlock
str x0, [x1]
/* Ensure that CPU 0 sees the write right now.
* Optional, but could save some useless CPU 1 loops.
*/
dmb sy
/* Wake up CPU 0 if it is sleeping on wfe.
* Optional, but could save power on a real system.
*/
sev
cpu1_sleep_forever:
/* Hint CPU 1 to enter low power mode.
* Optional, but could save power on a real system.
*/
wfe
b cpu1_sleep_forever
cpu0_only:
/* Only CPU 0 reaches this point. */
/* Wake up CPU 1 from initial sleep!
* See:https://github.com/cirosantilli/linux-kernel-module-cheat#psci
*/
/* PCSI function identifier: CPU_ON. */
ldr w0, =0xc4000003
/* Argument 1: target_cpu */
mov x1, 1
/* Argument 2: entry_point_address */
ldr x2, =cpu1_only
/* Argument 3: context_id */
mov x3, 0
/* Unused hvc args: the Linux kernel zeroes them,
* but I don't think it is required.
*/
hvc 0
spinlock_start:
ldr x0, spinlock
/* Hint CPU 0 to enter low power mode. */
wfe
cbz x0, spinlock_start
/* Semihost exit. */
mov x1, 0x26
movk x1, 2, lsl 16
str x1, [sp, 0]
mov x0, 0
str x0, [sp, 8]
mov x1, sp
mov w0, 0x18
hlt 0xf000
spinlock:
.skip 8
组装并运行：
aarch64-linux-gnu-gcc \
-mcpu=cortex-a57 \
-nostdlib \
-nostartfiles \
-Wl,--section-start=.text=0x40000000 \
-Wl,-N \
-o aarch64.elf \
-T link.ld \
aarch64.S \
;
qemu-system-aarch64 \
-machine virt \
-cpu cortex-a57 \
-d in_asm \
-kernel aarch64.elf \
-nographic \
-semihosting \
-smp 2 \
;
-smp 1启动QEMU，则模拟会永远停留在自旋锁上。上游版本还有一些调整，使其在gem5上工作，因此您也可以尝试性能特征。
我没有在真实硬件上测试过它，所以不确定这有多可移植。以下的 树莓派文献 可能会引起您的兴趣：
pthreads一样，您还需要涉及以下更深入的主题：
设置中断并运行定时器，周期性地决定现在将运行哪个线程。这被称为抢占式多线程。
这样的系统还需要在启动和停止线程时保存和恢复线程寄存器。
也可以有非抢占式多任务处理系统，但这些可能需要您修改代码，以便每个线程都能让出（例如使用pthread_yield实现），并且更难平衡工作负载。
以下是一些简单的裸机计时器示例：
处理内存冲突。特别是，如果要使用C或其他高级语言编写代码，则每个线程都需要一个唯一的堆栈。
您可以仅限制线程具有固定的最大堆栈大小，但更好的处理方式是使用分页，它允许有效地实现“无限大小”堆栈。
这些都是使用Linux内核或其他操作系统的好理由 :-)
尽管线程的启动/停止/管理通常超出了用户空间的范围，但您可以使用来自用户空间线程的汇编指令来同步内存访问，而不需要潜在更昂贵的系统调用。
当然，您应该优先使用可移植地包装这些低级原语的库。C++标准本身已经在<mutex>和<atomic>头文件上取得了巨大进展，并且特别关注std::memory_order。我不确定它是否涵盖了所有可能实现的内存语义，但它可能会。
futex 系统调用，它是 Linux 中的主要同步原语之一。 man futex 4.15 读取：系统调用本身的名称意味着“快速用户空间XXX”。
这是一个最小的无用C ++ x86_64 / aarch64示例，其中包含行内汇编，说明了这些指令的基本用法，主要是为了好玩：
main.cpp
#include <atomic>
#include <cassert>
#include <iostream>
#include <thread>
#include <vector>
std::atomic_ulong my_atomic_ulong(0);
unsigned long my_non_atomic_ulong = 0;
#if defined(__x86_64__) || defined(__aarch64__)
unsigned long my_arch_atomic_ulong = 0;
unsigned long my_arch_non_atomic_ulong = 0;
#endif
size_t niters;
void threadMain() {
for (size_t i = 0; i < niters; ++i) {
my_atomic_ulong++;
my_non_atomic_ulong++;
#if defined(__x86_64__)
__asm__ __volatile__ (
"incq %0;"
: "+m" (my_arch_non_atomic_ulong)
:
:
);
// https://github.com/cirosantilli/linux-kernel-module-cheat#x86-lock-prefix
__asm__ __volatile__ (
"lock;"
"incq %0;"
: "+m" (my_arch_atomic_ulong)
:
:
);
#elif defined(__aarch64__)
__asm__ __volatile__ (
"add %0, %0, 1;"
: "+r" (my_arch_non_atomic_ulong)
:
:
);
// https://github.com/cirosantilli/linux-kernel-module-cheat#arm-lse
__asm__ __volatile__ (
"ldadd %[inc], xzr, [%[addr]];"
: "=m" (my_arch_atomic_ulong)
: [inc] "r" (1),
[addr] "r" (&my_arch_atomic_ulong)
:
);
#endif
}
}
int main(int argc, char **argv) {
size_t nthreads;
if (argc > 1) {
nthreads = std::stoull(argv[1], NULL, 0);
} else {
nthreads = 2;
}
if (argc > 2) {
niters = std::stoull(argv[2], NULL, 0);
} else {
niters = 10000;
}
std::vector<std::thread> threads(nthreads);
for (size_t i = 0; i < nthreads; ++i)
threads[i] = std::thread(threadMain);
for (size_t i = 0; i < nthreads; ++i)
threads[i].join();
assert(my_atomic_ulong.load() == nthreads * niters);
// We can also use the atomics direclty through `operator T` conversion.
assert(my_atomic_ulong == my_atomic_ulong.load());
std::cout << "my_non_atomic_ulong " << my_non_atomic_ulong << std::endl;
#if defined(__x86_64__) || defined(__aarch64__)
assert(my_arch_atomic_ulong == nthreads * niters);
std::cout << "my_arch_non_atomic_ulong " << my_arch_non_atomic_ulong << std::endl;
#endif
}
my_non_atomic_ulong 15264
my_arch_non_atomic_ulong 15267
从这里我们可以看出，x86 LOCK前缀 / aarch64 LDADD指令使加法操作具有原子性：如果没有它，许多加法操作会存在竞争条件，并且最终的总计数少于同步的20000。
另请参阅：
在Ubuntu 19.04 amd64上测试，并使用QEMU aarch64用户模式。
#include（将其视为注释），NASM、FASM、YASM不知道AT＆T语法，所以它们也不是...那是什么呢？ - Ruslangcc，#include 来自 C 预处理器。请使用在入门部分中解释的提供的 Makefile：https://github.com/cirosantilli/x86-bare-metal-examples/blob/8ceb4b27a68d44318b58db4c48ccf8b95eca9f1b/getting-started.md 如果这样不起作用，请打开一个 GitHub 问题。 - Ciro Santilli OurBigBook.com据我所了解，每个“核心”都是一个完整的处理器，具有自己的寄存器集。基本上，BIOS从一个运行的核心开始，然后操作系统可以通过初始化和指向要运行的代码等方式来“启动”其他核心。
同步由操作系统处理。通常，每个处理器都在为操作系统运行不同的进程，因此操作系统的多线程功能负责决定哪个进程可以访问哪些内存，并在内存冲突的情况下进行处理。
确切地说，有4组寄存器，包括4个独立的指令指针。
如果是这样，当你说“增加EDX寄存器”时，是什么决定了哪个CPU的EDX寄存器会增加？
自然是执行该指令的CPU。可以把它想象成4个完全不同的微处理器，它们只是共享同一内存。
x86汇编现在有“CPU上下文”或“线程”概念吗？
没有。汇编程序员只需像以前一样翻译指令。没有变化。
多核处理器之间的通信/同步是如何工作的？
由于它们共享同一内存，这主要取决于程序逻辑。虽然现在有inter-processor interrupt机制，但它并不是必需的，最初在第一个双CPU x86系统中也不存在。
如果您要编写操作系统，硬件暴露哪种机制允许您在不同的核上调度执行？
调度程序实际上并没有改变，只是稍微更加注意关键部分和所使用的锁的类型。在SMP之前，内核代码最终会调用调度程序，该程序将查看运行队列并选择下一个要运行的进程作为下一个线程。（内核对进程的看法与线程非常相似。）SMP内核按顺序运行完全相同的代码，只是现在必须进行SMP安全的关键部分锁定，以确保两个内核不能意外地选择相同的PID。
是否有特殊的特权指令？
没有。所有核心都在同一内存中运行，使用相同的旧指令。
如果你要为多核CPU编写优化编译器/字节码VM，你需要了解关于x86的特定内容，以使其生成在所有核心上高效运行的代码。你运行与以前相同的代码。需要更改的是Unix或Windows内核。你可以将我的问题概括为“有哪些更改已经被应用到x86机器码中以支持多核功能？”没有必要进行任何更改。第一个SMP系统使用与单处理器完全相同的指令集。现在，x86架构发生了很大的演变，并增加了无数新指令来加快速度，但对于SMP来说，这些指令都不是必需的。如需更多信息，请查看Intel Multiprocessor Specification。