Skip to content

06 · 内存序与缓存一致性:两个作者,三档刻度,三口锅归位 ​

第 4 部一路攒下的票,到今天全数到期了,咱们一张一张收。4.1 立门闩的那会儿押过一张:test_and_set 配 acquire、clear 配 release,这对顺序背后还有什么讲究,归本章讲的就有缓存、重排、屏障,那一章认下白话就收了卷。4.4 收卷时指了第二扇门:sti; hlt 那口原子,封死的是中断的缝,不是内存的次序。指令与内存的那口深锅,开门的日子就是今天。4.5 的交棒交得也直:信号那把 gate,拿与放也是一对配好的次序,深一层的道理,归的就是这里。

咱们手里三张票,一张问的是屏障,一张问的是深锅,一张问的是配对,细看下来其实是同一桩事:次序这件事到底归谁管、管到了哪一层,谁收的钱、谁免的单。今天咱们把它弄清,第 4 部也就收官了。

票之外的话,咱们还有线头要结。1.7 讲存储塔的时候,咱们留过一句,那桩细目的名字叫缓存一致性,连着的还有内存屏障,留到讲内存序的那一章结。同一章还有一句留过的实话,上半截说的是没有屏,TCG 也是不演缓存的。

前置卷里的三根线头:讲内联汇编的那篇引过手册原话,asm 的 “memory” 为编译器构成了一道读写的内存屏障。《设备怎么碰》那一篇一根线头露了两回头,一回露的是句问话,设备寄存器出现的地方为什么不能让缓存随随便便吞掉,一回露的是收边的话,缓存一致性与内存屏障的事不归那几篇管。讲保护模式的那篇只留一句,想往下走的话,得去翻教科书里讲内存序的那部分。线头全指向的是今天这间屋子,咱们一根一根结。

本章的活,咱们数下来还是三样。头一样认的是次序的两个作者:编译器与处理器,谁在挪咱们的读写,凭什么挪。再一样认的是名字与刻度:内存模型这个词,语言里的三档,库里三处真身各配各的,顺带把 4.2 押下的那道题当面答了。末一样认的是价钱与欠债:屏障这道墙拦的是谁、不拦的又是谁,强机器与弱机器各掏的钱有多少,上线握手两场怎么把发布与开门配成一对,末了咱们把一致性讲到问题层为止,两笔欠债也挂回明处了。

量法还是老的三条。码的实况锚仍是 4.5 那一趟终态克隆,咱们不开新仓:base 的互斥件与引用计数,内核的门闩、心跳计数、上线握手,测试里的会合段,行号一处一处都落了名。屏的这一边,本章是零屏的:缓存一致性的内情与弱序机器的差价,咱们跑着的 TCG 机器一样也演不出,也就不造屏了。书的引用走的是 xv6 第 7 章:71 页上补几句没引过的原话,72 页 4.4 是按页转述过的,本章把跨页的收话整句摘下来,页号也写明了,您对着书核。

还有的是几行汇编,咱们把身份交代在前头。本章引的自家编译产物,是同款源码形状在家用编译器 g++ -std=c++23 -O2 下编出来的,拿它当规格常识的佐证,不冒充内核构建的镜像,更不是实况的屏。哪几行、什么形状,讲价差的时候您自然看到。

同一对的拿与放,在家用编译器手里编了出来,抢的那一拍,落的是一条 xchg,放的那一拍,落的是一条普通 mov,屏障的钱一分也没收。换到 xv6 那头的弱内存序机器,拿与放的两头都得真砌一堵全屏障。您想:同样的一句源码,凭什么两家两种价?

因为源码里写的只是一份约定。约定只管读与写被看见的次序,不说机器怎么兑现。x86 这门强序的家底厚,该掏的早就算在指令里,弱机器的家底薄,一笔一笔都是另买的。今天咱们就沿着这笔钱把次序这件事从头数清。

两个作者:一个在编译器里,一个在处理器里 ​

次序的第一位作者,咱们是老相识。4.1 办过那桩删循环的案中案:编译器看没人写那个旗,把读连同等待循环一起删了。案子 4.1 是整案收过的,xv6 书页 71 它自己招供的原话,读写指令的次序它敢换,没用的读写它敢删,整句的原话 4.1 也摘过,招供状咱们不重念。今天咱们升一层,把压在案子底下的原理请出来。

正文《轮流当家》那一卷记下的话,咱们整句搬来立在本章门口:编译器的世界里只有它看得见的因果,看不见的那些,一律不在它的世界里。同卷还有一笔:中断会异步地修改内存,这件事咱们从来没表达给编译器。挡得住靠的纯属运气。两句合起来、作者的脾气也就出来了:界内它讲理,界外它是不讲的,而中断与另一颗核,都住在它的界外。

第二位的作者住在处理器里,xv6 同一页介绍了它,咱们把书页 71 的原话整句摘来:

  • “Another reason is that the CPU may execute instructions out of order to increase performance. For example, a CPU may notice that in a serial sequence of instructions A and B are not dependent on each other. The CPU may start instruction B first, either because its inputs are ready before A’s inputs, or in order to overlap execution of A and B.”

咱们译过来:CPU 为的是跑得快,指令可以不按程序的次序执行。比方一串指令里 A 与 B 互不依赖的话,B 也就可能提前走了,要么 B 的料备得早,要么 A 与 B 正好叠着一起办。您看,第二位的作者挪起指令来,跟编译器挪起读写来的是同一种脾气。

原理落到处理器的身上,一个字也是不用改的:它的世界里,也只有它看得见的依赖,看不见的那些,一律不在它的世界里。编译器看的界,是源代码与语言约定划的。处理器看的界,是指令之间的数据来往。界内它是老老实实的:您一个人的程序,跑出来的永远像按次序跑,1.1 教过的行话叫 as-if 顺序。界外是没人担保的:两条执行流隔着共享内存打交道的地段,谁写的何时被谁看见,两位作者是一个字都没许诺过的。

次序是要人管的,管的手法就是把许诺买回来。正文《轮流当家》的那卷里,《被删掉的等待循环》一案的收尾立过一条底线,咱们原句搬来:跨执行流共享的变量,咱们必须用原子或屏障来表达,这是一条实打实的底线。这笔钱咱们一直在花,细看倒是从来没有过的。今天把花销摊开了:钱花的是哪一档,谁收的,强机器为什么打折。

push 反例,与约定的名字 ​

挪坏了是什么样,xv6 同页给过咱们一桩现成的反例,咱们把书页 71 的原话整句摘来:

  • “As an example of what could go wrong, in this code for push, it would be a disaster if the compiler or CPU moved the store corresponding to line 4 to a point after the release on line 6:”

原书接着摆了六行,咱们按它的行号数着念:头两行备的是料,造的是节点、填的是数据。第三行是拿锁的 acquire(&listlock)。第四行写的是 l->next = list,把新节点的 next 指向旧表头。第五行写的是 list = l,表头改指的是新节点。第六行是放锁的 release(&listlock)。要出事的正是第四行:这笔写要是被哪位作者挪到第六行之后,后果原书也写明白了:

  • “If such a re-ordering occurred, there would be a window during which another CPU could acquire the lock and observe the updated list, but see an uninitialized list->next.”

咱们译过来:真这么挪了,就开出了一扇窗。另一颗 CPU 拿到了锁,看得见表头已经改指了新节点,转到节点的身上读 next,读到的却是没写过的垃圾。

您细看这桩祸的形状:互斥一点没破,锁还是完整的一把,进门的次序还是一前一后。破的是另一件事,拿锁的人本该看得见上一任临界区里的全部写入。看得见的这一层,4.1 用传话管道的白话立过:release 是放行前的承诺,写统统落定了才放行。acquire 是进门时的要求,进门就要求读得到前任的一切。push 的反例,就是管道失约之后的具体惨状。

担保该怎么买,xv6 紧跟着就给了名字,咱们把书页 71 的原话整句摘来:

  • “The good news is that compilers and CPUs help concurrent programmers by following a set of rules called the memory model, and by providing some primitives to help programmers control re-ordering.”

咱们译过来一个好消息:编译器与 CPU 也不是无法无天的,它们照着一套名叫内存模型的规则办事,还给程序员备了几件管住重排的家什。

内存模型这个词咱们今天头一回正用,白话也就配上了:一份写明的约定,两位作者的哪些挪动许做、哪些不许做,全都写在上面了,掏钱的话程序员还能多买到几条不许。

C++ 把约定刻成了刻度,它的名字叫 std::memory_order,咱们一路上用过的正好三档。最松的一档是 relaxed,只保这一拍操作自己的不可分,前后的读写次序一概不承诺,正文数拍子那一桩选的就是它,白话是 4.1 配过的。

acquire 与 release 管的是两个半边,进门的要求与放行的承诺,4.1 立门闩时配齐的那一对。acq_rel 的一个名字装下两个半边,读改写用的,正戏是下一节的。标准里还有更严的 seq_cst 与用途冷僻的 consume,咱们全书不立它们的正题,也就点到为止了。

库里三处:三档各配各的仗 ​

刻度念完了,拿终态的码对照,三档是各有一处真身的,一处有它自己的道理。头一处是 tick.hpp 的心跳计数。4.1 那桩删循环案修法的真身就落在这儿,案子不重讲、咱们只认亲:fetch_add 带 relaxed 的真身在 :98,读的 load 也走 relaxed 在 :108,旁边 :114 到 :115 立着 is_always_lock_free 的静态断言,断言的话写得明白,这个计数不许走会拿锁的运行时。

为什么最松的一档就够,咱们看它数的是什么:数拍子数的只是这一拍本身、数到多少是多少,前后没有要跨流看见的家当。relaxed 保住这一拍的不可分,事情就清了,再严的档都是白花钱。

第二处是门闩的拿与放。sync.cpp 的 test_and_set 配 acquire 在 :98,clear 配 release 的位置在 :116,真身是 4.2 印过的,咱们这里只看次序:门闩护的是临界区,进门的人要求读得到前任的一切,出门的人承诺写统统落定,说的是两个半边,配的是一对档位,push 反例就是这对档位在防的祸。

门闩身上还有一笔松弛的,正好练一练您的眼力:owner_cpu_ 的登记走 relaxed,拿锁时的写落在 :102,放锁时的清回负一落在 :115。格子要紧的读者是本核自己,重入检查问的是这把锁是不是本核拿着,别的核写下的值,答案里是用不上的。本核是关着中断写、读的,天然是一前一后的。跨流的次序它一项不用买,relaxed 是刚好的。

第三处的正戏落在 ref_count.hpp,4.2 押的那道题,咱们当面答。押题您还记得:正文说的是 acquire 配 release 那一档,代码里落的是 acq_rel,凭什么一档当得起两样。

咱们把形状认了。fetch_add 与 fetch_sub 干的都是读改写:一拍里读的是旧值、改、写回,一口气也就办完了。4.2 摆这两段代码的时候,当的是计数讲。今天换的是眼光,当的是次序讲。读改写的一拍里有两个半边:读的那半边,要的是 acquire 的要求,读回来了之后,别人前头写下的东西都得看得见。写的那半边,要的是 release 的承诺,我这一拍落下之前,我前头的写统统落定。acq_rel 的一档,就是两个半边各领各的名分,合写在了同一笔里。

凡读改写的都是这门亲:fetch_add、fetch_sub,后头会合要用的 fetch_or,全都是一样的。您往后见到读改写,在心里分出的就是两个半边,档位怎么配,答案就在分出来的两半里。

这套答案在实弹里怎么承重,正文《请第二颗脑子上线》那一卷的原话给得干脆:减到零的那颗核,必须看得见所有曾经持引用的核写下的全部操作,保证这一点的正是拿与放那一对顺序。咱们顺着数:每一位放手的核,release 半边把自己临界区里的写封进那一笔减法。轮到减到零的那一笔,acquire 半边把历代前任的写全都收进眼底、析构这才敢做。

4.2 那桩十万次加减的实弹,您回头想那十万笔,笔笔都是两个半边担着的。

码上的落位,咱们一处一处报。retain 的 fetch_add 带 acq_rel 在 :49。release 的 fetch_sub 同款在 :61,减出来的旧值等于一的那一问在 :63,认下的就是最后一任。旁边 use_count 的读配 acquire 在 :67,给外头的旁观者一个读得到的口径。计数出生自带的一落在 :70,头一个引用是娘胎里带的。

答完了题,4.2 摆下的那笔措辞差,今天摆到的是第三层。第一层是正文那一卷的原话:顺序咱们选 acquire 配 release 那一档,念的是两个名字配成一对。第二层是 ref_count.hpp 在 :24 的类注,写的是 publish with acquire/release ordering,说的还是那对名字。第三层是落在码上的::49 与 :61 的两处,写的都是 std::memory_order_acq_rel,一档配的是一个词。

咱们把三方对一遍、谁也没改谁,三种念法都是对的:名字念的是两个半边,档位念的是合写的一档,合起来的意思您在上一段已经读到。咱们把三层原样摆开、不替谁圆场,您三门对过,自己就对得上了。

只拦编译器的墙 ​

三档之外、还有一道屏障的射程要认清。SpinMutex 的拿锁您在 4.2 看过三层,咱们只请围栏那一行出来,spin_mutex.hpp 的 :52:

C++
                std::atomic_signal_fence(std::memory_order_seq_cst);

这声围栏的正名叫信号围栏,今天咱们头一回叫它的大名,白话是一道只拦编译器的墙。它管的是两件事:不许编译器把圈里的等待优化没了,不许把圈里圈外的读写挪错位。这两件 4.2 也都是说过的,今天补的是它的射程与身价:它对处理器一个字也没说,落到机器码里是一条指令都不添的,处理器侧是一分钱不花的。参数里的 seq_cst,全谱里最严的一档,4.2 印那三层的时候它露过脸,今天给它配上的是白话,全书也就配这一回了。

处理器层的次序归谁管?4.2 答过半句,由拿与放自身的语义担着,话也就说到往深处去为止了。今天咱们把这半句接完:管的就是 acquire 与 release 这对名字,它们是写给处理器的承诺。正文《请第二颗脑子上线》那一卷的原话,给这问答得干脆:拦住编译器乱序的墙只有编译期的信号屏障,处理器层的顺序,由拿与放自身的语义担着。

圈里那声 test(relaxed) 为什么敢用,咱们顺着这问再走一步。4.2 是从钱上讲过一遍的:原子那一拍要把缓存行攥在手里独占,普通读是只看不动手的,是要便宜得多的。今天从次序上补一刀:圈内的读只有看的份,没有一笔要跨流保的写,acquire 与 release 的承诺,它是一项也用不上的。墙拦的是编译器,名字管的是处理器,圈内的读两边都不沾,这笔花销才配得这么省。

这道墙的前身您其实见过。前置卷《写:内联汇编》那一篇教 asm 的时候引过手册的话:“memory” 告诉的是编译器,这块 asm 对操作数之外的内存也动过手。手册说的是,这为编译器构成了一道读写的内存屏障。

那一篇当时也划了界:这道屏障管的是编译器,处理器自己往 asm 之后做的是推测读,它是拦不住的,处理器那边的乱序另有 fence 一类的东西管着。划界划掉的那半句,今天接上了:另有的 fence,指的就是 acquire 与 release 的这些承诺,接上的地方就是本章。前置卷的三根线头,内联汇编的这一根结在这儿。《设备怎么碰》那根,咱们到欠债一节结。保护模式的那根,门开了就算结了。

咱们停一停。同一对的拿与放,源码里写着的是 acquire 与 release,x86 底下编出来一条 xchg 一条 mov 就交代了,屏障的钱一分没收。您想:这套次序到底是写给谁的?

答案写给的只是约定、不落在某台机器身上。内存模型只认的是承诺,不问兑现的成本。底下压着的是哪台处理器,编译器自己会去掂量的。咱们看两家各怎么算,价差就在两家的中间。

价差:一家砌真墙,一家免单 ​

xv6 的一头,咱们把书页 71 的原话整句摘来:

  • “To tell the hardware and compiler not to re-order, xv6 uses __sync_synchronize() in both acquire (1271) and release (1302). __sync_synchronize() is a memory barrier: it tells the compiler and CPU to not reorder loads or stores across the barrier.”

咱们译过来:要告诉的是硬件与编译器别重排,xv6 在 acquire 与 release 的两处都放了 __sync_synchronize(),行号写的是 1271 与 1302。咱们给它配句白话:墙立在哪儿,读和写也就不许挪过去了,不分只管读的还是只管写的,两边是统统拦的。xv6 的机器是 RISC-V,弱内存序的一头:处理器天生答应得少,约定上没买的次序它一概不担保,拿与放的两头都得砌真墙,屏障的钱一分也省不下。

咱们这边,拿自家编译的产物对。抽形状的小程序咱们叫探针,拿它往编译器的身上扎一针,看它报出来的是什么。探针的源码,把 SpinMutex 的形状抽出来:一把 atomic_flag 当的是门闩,抢门的是 test_and_set(acquire),圈里盯的是 test(relaxed),放门的是 clear(release),在家用编译器 g++ -std=c++23 -O2 下编成了汇编。三处要害各请的是一行。抢的那一拍,test_and_set 配的是 acquire:

asm
	xchgb	(%rdi), %al

咱们看圈内那一眼,test 配的是 relaxed:

asm
	cmpb	$0, (%rdi)

咱们看放锁那一笔,clear 配的是 release:

asm
	movb	$0, (%rdi)

三行咱们挨着念。抢的那一拍落成 xchg,x86 的交换指令。xchg 指令跟内存打交道的时候,硬件自动配上的是锁定,前缀是都不用另写的,原子的一拍与次序的承诺,一条指令是全包的。

放锁的那一笔,落成一条普通的 mov。圈内的那一眼,落成一条普通的 cmp。您数源码里的次序名,acquire、relaxed、release 各占的是一档,机器码里是没有一条屏障指令的。

为什么敢不掏:x86 这边是强内存序的机器,它天生答应的次序就严,咱们买的那点次序,它本来就是白送的,编译器掂量完了,也就免单了。

RISC-V 是弱的那一头,同样的源码,兑现是要真掏屏障的,xv6 那两声 __sync_synchronize 就是掏钱的凭证。强弱内存序的这对词,咱们今天立成术语:强机器答应多、屏障钱少,弱机器答应少、什么都得另买。

xv6 自己也给这道墙收了话,句子是跨页的,起头在 71 页的末行,咱们整句摘下来,页码记的是 71-72:

  • “The barriers in xv6’s acquire and release force order in almost all cases where it matters, since xv6 uses locks around accesses to shared data. Chapter 11 discusses a few exceptions.”

咱们译过来:这两道屏障在几乎一切要紧的地方都压得住次序,因为 xv6 访问共享数据都是裹着锁的。第 11 章讨论的是少数例外。例外那半句咱们点到即收,第 11 章咱们没翻开过,不越界替它念的。

末了把边界交代清楚。探针是同款形状在家用编译器手里的产物,不是内核构建的镜像。它证明的是约定在 x86 这门指令集上的价钱,是不冒充实况的。真到实况的话,咱们也演不出弱序机器上的差价:机器跑在 TCG 上,1.7 说过的,上半截是没有屏的,TCG 是不演缓存的,弱序同样也是不演的。两头都是没有现场的,咱们手里只有规格常识,这句诚实的话,与 1.7 那半句是同款的。

上线握手两场:发布带 release,开门用 acquire ​

约定与价码都清了,咱们看两场真枪实弹,都落在 smp.cpp 的家里,第二颗核上线的路上。头一场说的是就绪屏障。副核一路跑到内核世界的门口,把自己收拾利落:本地的中断芯片、定时器、机制快照,全弄妥了,才轮到了发布。发布的那两行,咱们抄来,smp.cpp 的 :157 起:

C++
    g_online[cpu].store(true, std::memory_order_release);
    g_online_count.fetch_add(1, std::memory_order_release);

咱们看这两笔:一笔写自己的在线旗,一笔给全机的在线数加一,两笔都带的是 release。带它干什么:发布之前的全部收拾,统统是要赶在旗立起来之前落定的。头核看见了旗,就得看见收拾利落的全部。

咱们看这一放一取,正是 4.1 传话管道的两头,在真弹里握的手。顺带咱们报一笔出生家底:在线数生下来就是一,记这笔的地方是 :66,头核把自己算作了头一颗。副核到齐了,头一笔加法就把数目添成了二。

头核的那一头,咱们看 smp.cpp 的 :230,原地自旋,等的是在线数涨过自己,load 配的正是 acquire:

C++
        while (g_online_count.load(std::memory_order_acquire) <= cpu) {

正文《请第二颗脑子上线》那一卷记这段的话,咱们对读两句:发布的那一笔带 release 顺序写在线标志,累加走的是原子加法。一颗一颗地来,不做批发的生意。为什么一颗一颗:头核等的是每一颗各自到齐,谁的快照谁自己发布,谁的旗谁自己立。

您试想图快的样子:数目涨在头里、收拾补在后头,头核看见数目就抬脚进了门,遇到的就是没写完的家当,和 push 反例害的是同一个病,只是把锁换成了计数。

第二场咱们看的是分发许可位。核上了线,不等于能开工:g_dispatch 出生就是关的,记它的就是 :69。副核进了空闲循环,一遍一遍问的只是 :160 这一句,load 配的是 acquire。头核的那一头,把调度器的类注册表、初始任务、文件世界都备齐了,才把许可位这么一放,放的地方在 :253,store 配的是 release:

C++
    g_dispatch.store(true, std::memory_order_release);

正文同卷记这段的话,咱们接着对:全局一个分发许可位,头核把许可位这么一放,再广播了一声。分两拍发布的思路,头一拍发的是就绪屏障,第二拍发的就是这道许可。为什么非要两拍:许可开早了,副核冲进共享的队列,拿到的是没写完的元数据,头核单手的半成品。

您看,没写完的元数据,又是 push 反例的亲戚。

4.5 交棒问的那句,为什么拿与放非配这一对不可,答案全摆在这两场里了,咱们再收拢一遍:发布带的是 release、开门用的是 acquire,一放一取配齐了,管道也就接得上了。配反了或者不配,开门的人看见的就可能是没写完的世界。信号那把 gate 配的也是同一门,真身住在 signals.hpp 的 :64,拿与放的一对档位,护的是 4.5 交下的那两段路。

会合与欠债:报号那一拍,与硬件的私务 ​

握手之外还有一场次序的实弹,三个人凑齐了才开场。机内块设备测试里的 meet_on_both_cpus,test_block.cpp 的 :39,咱们整段抄:

C++
void meet_on_both_cpus() {
    const cinux::arch::IrqGuard kGuard;
    g_cpu_mask.fetch_or(cinux::base::bit::MaskBit<unsigned int>(
                            static_cast<unsigned char>(cinux::arch::per_cpu::PerCpu::self().cpu_id))
                            .raw,
                        std::memory_order_acq_rel);
    while (g_cpu_mask.load(std::memory_order_acquire) != 3) {
        cinux::arch::CpuRelax();
    }
}

咱们把会合走一遍。三位工人的活,开场全押在这场会合的身后。会合认的是核、不认的是人:进来的头一件事是把中断关死,干这件的就是 :40 的那件 IrqGuard。干的第二件,把自己那一核的位 fetch_or 进 g_cpu_mask,:41 的那几行就是它,次序落的正是 acq_rel。末了的一件,acquire 的读盯着掩码,:45 的那几行就是它,等到它变成 3、两位都到齐了才放行。

您眼熟吧,fetch_or 又干的是读改写,acq_rel 又是两个半边一起担的,与引用计数的那道押题,同一个答案换的是一件衣裳:报号的那一拍,读半边把别人前头的报位收进眼底,写半边把自己的报位封进这一拍。凑成的 3,两位看得见的是同一个 3。

为什么全程裹着 IrqGuard,正文《破案:被吞掉的完成通知》一篇的原话:报号到放行的全程本核关中断,不然刚记完号人就给迁走了,凑数的永远差一位。您把这句与 4.4 那口 sti; hlt 的锅放在一起看:两口都是中断的缝,一个怕的是刚记完号就被迁走,一个怕的是刚开闸就被人叫醒,封法各是各的,要护的东西一样,窗口里的状态,旁人是插不进手的。

同款的会合,咱们再点一处,机内的 smp 测试里也立着,test_smp.cpp 的 :83 起:报位走 fetch_or(acq_rel),等齐走的是 acquire 自旋,和块设备测试摆的是同一个形状。案名起的是直白话,:219 记着的就是 smp: two CPUs dispatch shared tasks and contend on a real spinlock,两颗核办的是同一批活、真抢的也是一把自旋锁。块设备测试的末了还有一声断言,断在 :100 的就是 ASSERT_EQ(g_cpu_mask.load(), 3U),两位到齐了,这笔就记进了案卷。两处咱们引名引行,屏是不引的。

会合的次序是咱们自己管得着的。再往下问一层的话,就问到了硬件跟前:两颗核各揣着各的缓存,同一个格子你写一笔我读一笔,怎么保持同一个说法?4.2 白话过半句,说的就是原子那一拍要把缓存行攥在手里独占,那是已刊的半张脸。今天升到的是问题层,给它正的名:问到这一层就停,机制是有名有姓的,协议怎么商量不再往下拆。这背后有一整套硬件内部的商量,行话叫的是缓存一致性,白话:各核的缓存副本之间保持同一个说法的那套机制。

它怎么商量、协议长什么样,是硬件的私务。咱们一台 TCG 机器验不了,书架上也没有核过的本子,规格常识也就讲到问题层为止了,一句是不多写的。您只需记牢线画在哪:承诺是语言的,原子与次序咱们找语言买。兑现是硬件的,承诺落到缓存行上怎么变成真,硬件自己的事。硬件兑现得了,咱们买的承诺才算数。

头一笔的欠债,咱们记 TLB。3.2 教过的,它是翻译的速查缓存,页号到物理页的小本本。小本本是每核一本的,所以它也是一种各揣一份的缓存,而它不在那套商量机制里,各核各记各的。

考古的案子,咱们在正文《破案:被吞掉的完成通知》一篇里同场见过:写时复制改页那阵,父进程把页改成了只读,没冲另一颗核的 TLB,那颗核的簿子里还留着可写的旧翻译,照着旧翻译写了下去,共享页就此遭了污染。当年修的全局冲刷够用,靠的是 fork 全程关着中断。

如今 fork 的路不再全程关中断,当年那刀治不了今天的病,而跨核的远端冲刷,那一篇的原话咱们照录:那个真正的完备解,咱们如实登记为欠债。今天挂在明处的欠条,几时还、怎么还,书里走到那儿的话,咱们再算。

第二笔记的是设备。前置卷《设备怎么碰》那一篇两回露头的线头,问的是设备寄存器出现的地方为什么不能让缓存随随便便吞掉,今天咱们把它结到问题这一层为止。机器对外的两扇门您在 1.5 见过,显存那一扇是不用报门牌的,地址算好 mov 就到。这样的门行话里叫的是 MMIO,全称写的是内存映射 I/O,白话讲的就是把设备寄存器编进内存地址里、读写当内存使。

地址背后坐的是设备,您读它,问的是设备的现状,您写它,按的就是铃。差事要是被缓存当热字扣下了副本,问话也就答不准了,铃也可能按了没响,所以这样的门,走法上是要绕开缓存的。

DMA 那头是反着来的。引擎替设备往内存搬的是字节,这笔买卖 1.6 是教过的。搬完的字要是还压在缓存的旧副本底下,CPU 读到的就是搬家前的旧底。所以 DMA 的搬运要与缓存打招呼。怎么绕、怎么打招呼,是设备模型的细节,咱们没翻到那页书,也就不编了。第 5 部的块设备与驱动开讲,欠条是记在那边的。1.7 挂下的那句线头,那桩细目叫的是缓存一致性,连着的是内存屏障,今日两头都点到了名,也就结清了。

这一章留下了什么 ​

术语一句话口径
内存模型一份写明的约定:两位作者哪些挪动许做哪些不许,掏钱能多买几条不许
relaxed最松一档:只保这一拍自己不可分,前后的次序一概不承诺
acquire 与 release两个半边:进门要求读得到前任一切,放行承诺写统统落定
acq_rel读改写的一档:读半边配 acquire,写半边配 release,合写一笔
内存屏障墙立在哪儿,读写就不许挪过去,xv6 拿与放两头都砌
信号围栏只拦编译器的墙:机器码里一条指令不添,处理器侧零开销
强弱内存序强机器天生答应严,屏障钱免单,弱机器答应少,什么都得另买
缓存一致性各核缓存副本保持同一个说法的机制,协议是硬件的私务
两场握手就绪屏障与分发许可位:发布带 release,开门用 acquire
报号会合fetch_or(acq_rel) 报位,acquire 读等凑齐,全程关中断

押出去的票,咱们清一清。开篇接的是三张,另三张是还押着的。4.1 的头一张,问的是顺序背后的讲究,两个作者一节开了头,补齐的后半归的是刻度与价差。4.2 的两张,往深处去的那半句,墙一节接完的是它。一档当得起两样凭什么,库里三处当面答了。4.4 的两张,说的就是第二扇门与那口深锅,开篇接的就是票,三口锅在收束一节归的位。4.5 的一张,gate 的拿与放,握手两场交了底,配对配的是管道,管道给的正是看得见。1.7 与前置卷的三线头,开篇里都对到了名下,欠债一节结清的也是它们。十万次的实弹与红区那 128 字节,各回的是 4.2 与 4.5,出处都是齐的,咱们也就不重念了。

咱们把三口锅归位。4.4 立的原子三口锅,今天咱们当众分清。头一拍说的是指令级的不可分,test_and_set 把检查与写捆在同一拍的指令里。一缝封的是中断,sti; hlt 把开中断与睡觉之间那道缝封死了,那是单核执行流内部的原子。一把锁管的是查词与进桶,靠的是锁不是指令,说的是 4.4 点过的词上的等待。三口锅各管各的原子。

深锅今天开盖:指令与内存的次序,跨核看得见的早晚,原来从头到尾是 4.1 立下的传话管道在管:release 那头把写封进去,acquire 这头把写收进的是眼底。它是不在那三口锅里的,咱们也不新开第四口。原子答的是这一拍可不可分,次序答的是这一拍与别的读写被看见的早晚。其实是两码事,一口锅是不替两家背的。

第 4 部到这儿收官了,咱们把六门课合起来数。4.1 立的是竞态与临界区:一份共享财产、三路对手、一把门闩。4.2 立的是锁的实现:三句旧债、三处修法,几位护法各配各的仗。4.3 立的是死锁与锁序:一张锁序图,专查环在合上之前的那一步。4.4 立的是条件等待:一张押票、三句口径、五家等待。

4.5 立的是信号:两段路、一扇回家的门。今天立的是次序:两个作者、三档刻度、一道只拦编译器的墙、强弱两种价。往后的门 4.5 指过了,TTY 与线程的戏都在第 5 部开演,咱们数完即止。

咱们把边界如实挂。一致性协议的细节不立,TLB 远端冲刷与设备侧的两笔,是记着欠的。seq_cst 与 consume 咱们只点过名。volatile 为什么顶不了这门差,4.1 交过底的,您回指就是。Linux 的屏障家什,是没翻过的,也就不比了。信号的机件与红区那 128 字节,归的是 4.5。第 11 章的例外,点到的只有半句。咱们一句没展开的,都写了去处。

练一练 ​

三道题留给您:一道推演的,一道回望的,一道读册的。

题一咱们来推演。 SpinMutex 的 unlock 里,clear 的那一笔要是从 release 降成 relaxed,您推一遍:互斥坏不坏?坏的是哪一样?祸要几样东西凑齐才现形,又在哪台机器上才现形?

题二咱们来回望。 三档的刻度,终态码里三处真身:tick 的计数、门闩的拿与放、引用计数。您各配一句,为什么非那档不可,降一档会少什么?

题三咱们来读册。 回的是 xv6 书页 71 那六行 push,您答两问:第四行的写挪到放锁之后,另一位 CPU 拿到了锁,看得见的是什么,看不见的是什么?xv6 的拿与放两头都要 __sync_synchronize,咱们的 test_and_set(acquire) 与 clear(release) 一条屏障不另掏,差价差在谁身上?

参考答案 ​

题一的话,互斥是不坏的。clear 自己还是原子的一拍,您想,旗还是当初的一份,翻到旗的就进门,门也还是当初的那一扇。坏的是管道:release 承诺的临界区里的写在倒旗之前统统落定,这一档撤了,写与倒旗之间没了次序,下一位拿到了锁,读到的可能是没落定的写。祸要两样凑齐才现形:临界区里真有一笔要传的写,另一颗核拿到了锁就去读它。x86 强内存序还替咱们兜着,真现形是要等弱序机器的。4.1 的那对白话里,放行的承诺那一半,担的就是这个活。

题二:咱们一处一处配。tick 数的是拍子,relaxed 是刚好的:它只要这一拍自己不可分,前后没有要跨流看见的家当,再严也就是白花钱了。门闩要的是一对半边:进门要读得到前任的一切,出门写的要统统落定,少了半边就是 push 反例。引用计数走的是读改写,acq_rel 两个半边一起担:减到零的那颗核要看得见全部前任的写,降成了 relaxed,数目照样是算得对的,家当却是看不见的,析构就敢在别人的写还没被看见的时候动手。

题三:咱们来答。看得见的,表头已经改指了新节点,那一笔写在放锁之前落了地。看不见的,新节点自己的 next,那一笔被挪出了门。差价差在的是机器、不是约定:xv6 的 RISC-V 是弱序,买下的次序要真屏障兑现。咱们的 x86 强序,买的那点次序它本来就送。同一句的源码,两家开出的是两种价。源码里写的永远是约定。

延伸 ​

  • xv6 书第 7 章(书页 63 到 74):71 是引过的页,本章在它上面引的是没引过的句子,处理器乱序、push 反例、内存模型句、屏障句。72 那页 4.4 按页转述过一句,本章头一回整句摘,摘的是跨页的收话。连同 4.1 到 4.5,第 7 章咱们引到第八页。第 11 章的例外,半句点到,书咱们没翻到那儿。
  • CSAPP 2e 第 12 章 12.5 节(电子版正文页 992 到 999):4.1 与 4.2 引的都在,本章一页未添,您回着看。
  • TLPI:4.5 开的书,咱们本章一页未添。
  • 正文《轮流当家:让出来的,抢出来的,排出来的》一卷:《被删掉的等待循环》是镜像原理与底线句的原篇,《转圈的门闩》是那对顺序白话的出生地。
  • 正文《请第二颗脑子上线:APIC、蹦床与共享调度》一卷:《同步层的旧债》是三处分工与措辞差原话的出处,《破案:被吞掉的完成通知》记着三位工人与 TLB 那笔欠债的登记。
  • 前置卷《写:内联汇编》《设备怎么碰》《保护模式与长模式预览》:三根线头的原句各在各家,今日一并结清,您回去对原句。
  • 第 5 部的块设备与驱动:MMIO 绕开缓存、DMA 与缓存打招呼的细节在那边。TTY 与线程的戏,4.5 已经指过门了,本章只收尾。

r35_gui_fin-9-gb5c5b55 · b5c5b55 · 2026-11-02