btrfs vs zfs
btrfs是一个支持写时复制的文件系统，同时zfs是另外一个也被广泛使用的文件系统。
btrfs使用红黑树，zfs使用另外一套技术，zfs在大型机器上似乎是被广泛使用，处理大型文件的性能上优于btrfs，并且存储文件没有上限，btrfs文件数量上有上限，同时处理小文件更快。
具体来说优劣势：
btrfs在Linux内核直接有支持，内存使用更小
zfs更适合大负载场景，支持数据自动还原，跨平台。
btrfs vs ext4
因为btrfs支持COW，所以在写入小文件时效率可能更低。相比ext4，btrfs更适用于需要快照、数据完整性检查和内置RAID等功能的高级用户。
ext4是使用日志记录，在每次写入都会记录，虽然如此，但是ext4在日常使用效率比btrfs要好。所以如果对于快照和RAID支持没有需求的人应该选择Ext4。
之前写了一篇关于表达很佩服云峰的内容，他10年期间github的提交以及博客的更新是非常厉害的。今天又多一个让我钦佩的大佬：Erik Wernquist。
视频《ONE REVOLUTION PER MINUTE – a short film by Erik Wernquist》 https://erikwernquist.com/one-revolution-per-minute。
我不知道他是谁，但是他这个作品很浪漫，很厉害。
最近有点复古，开始寻找优秀的个人网站和频道，不太商业化和蹭热度的那种，用feedly去看那些大牛的日常和产出。
觉得这个是一个不错的思路，跳过平台去关注有意思的内容生产者，进一步的是寻找一些榜样。
他们的东西会淋我在身上，同时随着雨滴炸裂开的还有源源不断地新鲜灵感。
还是那句话，保持优秀信息的摄入。
看到低代码平台，心里就开始吐槽，这有啥用啊。
然后愣了一会
这平台不是给程序员的，这个就是给普通产品的开发工具。我本能地想从性能上反驳，但是从python的大流行去看，从摩尔定律失效来看，个人设备的计算力早就过剩了，绝大多数的产品需求是不需要那么强大的计算力的，所以性能低又怎么样，降低对程序员的要求是一个不可阻挡的趋势。
趋势也不是今天才开始，几十年来计算机行业的迭代本身就是降本增效。即降本，也增效。
没人能用汇编做出来一个原神，开发语言和工具的不断进步，既降低了对开发者的要求，也提高了项目能达到的规模。在开发的过程中也在优化开发过程本身。
这个时候，AIGC如神降临，而在某个虚空倒计时开始默默转动。
今天摘抄的一句话：产品是资产，代码是负债。
你的产品解决了客户的问题，因此是你的资产。代码则是创造资产的成本。你拥有的代码越多，阅读、测试、更改和理解所付出的成本就越高。
写的有点悲观，虽然趋势不可挡，但是抛开时间去谈趋势就是扯淡，而且落实到我自己身上又是另外一个课题。
始终要有预期，比如我认为腾讯300是最低了，那300就可以梭哈；如果我认为会跌倒200，那我就不应该在300满仓。
包括沪深300也是，我现在开始建仓，我得有一个预期最低的仓位，到那个仓位直接满仓。可以是拍脑袋，也可以是某种计算，过程不重要。
但是对于仓位和价格的预期很重要。
垃圾回收算法笔记
分为两个阶段：标记阶段和清除阶段；从根节点标记所有未被引用的垃圾对象，然后清除阶段删除。
优点：
缺点：
从根节点扫描，标记所有存活对象，并且复制到新的内存，回收旧内存。现在的商业虚拟机都采用这种收集算法来回收新生代。
优点：
缺点：
标记压缩算法是一种老年代的回收算法，它在标记清除算法的基础上做了一些优化。从根节点对所有可达对象做一次标记，然后将存活的对象压缩到内存的一段，之后清理边界空间。
优点：
缺点：
分代收集算法是目前JVM虚拟机使用的回收算法。它将内存分为各个年代。一般情况下将堆区划分为老年代和新生代，在堆区之外还有一个代就是永久代。
在不同的代使用不同的算法，从而使用最适合的算法。
引用计数，就是记录每个对象被引用的次数，每次新建对象、赋值引用和删除引用的同时更新计数器，如果计数器值为0则直接回收内存。
优点：
缺点：
将GC的阻塞任务拆分成少量多次，减少暂停用户程序的执行。
原因：
漏标的充分必要条件是：
避免漏标打破上述任何一个条件即可：
优点：缩短最大暂停时间
缺点：降低了吞吐量
Minor GC
只回收新生代，这里非常频繁且对象大多数死亡频繁，所以选择速度快效率高的算法。
Full GC
对整个堆进行回收，包括新生代和老年代，所以比Minor GC要慢，应该尽可能减少Full GC的次数。
python分配<512btype的内存时使用内存池，释放时不会还给系统；分配>512字节的对象时会直接使用C的allocate分配和管理。
标准CPython实现的垃圾收集器有两部分组件构成，一部分为引用计数模块(reference counting collector), 另一部分为分代垃圾回收器(generational garbage collector)。
引用计数是本意，但是无法处理循环引用，所以补充了分代垃圾回收器。
有三种情况会触发垃圾回收：
当循环引用的两个对象都有del时，python不知道先调用哪个导致不会释放，把它们标记为：uncollectable。
这个方法涉及到之前说过的分代回收的策略。python中默认把所有对象分成三代。第0代包含了最新的对象，第2代则是最早的一些对象。在一次垃圾回收中，所有未被回收的对象会被移到高一代的地方。
gc.get_threshold()
这个方法返回的是(700,10,10)，这也是gc的默认值。这个值的意思是说，在第0代对象数量达到700个之前，不把未被回收的对象放入第一代；而在第一代对象数量达到10个之前也不把未被回收的对象移到第二代。可以是使用gc.set_threshold(threashold0,threshold1,threshold2)来手动设置这组阈值。
虚幻的GC挺复杂的，因为虚幻本身提供了一套非常复杂且自由的系统。
只看UObject类的话就会简单一些，它是Unreal的基础类，它使用的是标记-清除算法，而不是传统类似于shared_ptr这样的引用计数。
学习文档：
https://aijishu.com/a/1060000000080557
https://www.jianshu.com/p/a8a04fd00c3c
https://developer.aliyun.com/article/777750
https://zhuanlan.zhihu.com/p/83251959
https://dreamgoing.github.io/Python%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6.html
菱形继承：菱形继承的问题在于数据冗余和二义性。
将子类转化成爷爷类的时候会报错，因为不知道要转化到哪个类上去，这里需要加入static_cast才行。爷爷类会在两个父类中都被定义，解决的办法是：虚拟继承。
虚拟继承让被菱形继承的父类只会存在一份，消除数据冗余，那这里就得问一下，内存是如何布局的呢？如何访问内存呢？
虚拟继承跟普通的继承不一样，普通的继承是通过将父类的内存放在子类的前面来实现，但虚拟继承父类的内存是放在后面的，那菱形继承会让父类和爷爷类的偏移不一致，那如何寻找爷爷类呢？
虚拟继承依然会前置一个值，只是不再是前置父类而是前置一个虚基表指针，指向的是内存中，父类相对于自己的偏移量。
虚继承支持基类的常规转换，主要是解决了多个派生类对基类的拷贝问题，并没有解决多重继承的二义性问题。
然后关于vs和g++的实现是不完全一样的，g++的实现是虚函数和虚基类地址偏移共享一个虚表，类的实例开始处即为所属类的虚指针。因为存在虚基类地址偏移，所以几乎每个类都会有一张独一无二的虚表。
虽然有一些大概的了解了，但是能不用就别用，这个机制很慢，内存很大，并且很违反直觉。
然后在实际实验的时候一直有一个不太理解的地方，就是虚函数表似乎总是对不上：
class A
{
public:
virtual void Test(){return;}
int _a;
};
class B
{
public:
virtual int Test2(){return 1;}
int _b;
};
class C : public A, public B
{
public:
virtual int Test2(){return 2;}
virtual void Test(){return;}
int _c;
};
int main()
{
C *c = new C();
c->_a = 1;
c->_b = 2;
c->_c = 3;
return 0;
}
然后我打开gdb去分析，去看具体的内存布局：
(gdb) start
Temporary breakpoint 1 at 0x400666: file test.cpp, line 25.
Starting program: /tmp/test
Missing separate debuginfos, use: debuginfo-install glibc-2.17-326.el7_9.x86_64
n
Temporary breakpoint 1, main () at test.cpp:25
25 C *c = new C();
Missing separate debuginfos, use: debuginfo-install libgcc-4.8.5-44.el7.x86_64 libstdc++-4.8.5-44.el7.x86_64
(gdb) n
26 c->_a = 1;
(gdb)
27 c->_b = 2;
(gdb)
28 c->_c = 3;
(gdb)
30 return 0;
(gdb) x /16wa c
0x602010: 0x400830 <_ZTV1C+16> 0x0 0x1 0x0
0x602020: 0x400850 <_ZTV1C+48> 0x0 0x2 0x3
(gdb) x /8wa 0x400830
0x400830 <_ZTV1C+16>: 0x400702 <C::Test()> 0x0 0x4006ec <C::Test2()> 0x0
0x400840 <_ZTV1C+32>: 0xfffffffffffffff0 0xffffffffffffffff 0x4008a0 <_ZTI1C> 0x0
(gdb) x /8wa 0x400850
0x400850 <_ZTV1C+48>: 0x4006fb <_ZThn16_N1C5Test2Ev> 0x0 0x0 0x0
0x400860 <_ZTV1B>: 0x0 0x0 0x4008e0 <_ZTI1B> 0x0其实很好理解的，0x400830是A类的虚函数指针指向虚函数表，虚函数表第一项是A的Test，第二项是B的Test2，那如果转化成A类也能按照同样的规则获取到Test这个虚函数。
那0x400850是什么呢？它所指向的0x4006fb <_ZThn16_N1C5Test2Ev>是什么意思呢？真的琢磨了很久，然后想起来gdb 的x指令里/i是可以输出汇编指令。
再进一步查看这个地址的汇编：
(gdb) x /2wi 0x4006fb
0x4006fb <_ZThn16_N1C5Test2Ev>: sub $0x10,%rdi
0x4006ff <_ZThn16_N1C5Test2Ev+4>: jmp 0x4006ec <C::Test2()>忽然就理解了，0x400850地址依然是一个虚函数表，第一项仍然是虚函数，并且就是C::Test2，那为什么不是直接指向C::Test2呢？
因为C::Test2()是C这个类的函数，它的this应该要指向一个C的类，但是使用0x400850虚表的对象偏移是不对的，所以这个函数在实际执行C::Test2()之前要将this向前挪16个字节。
至此，我觉得我比较深刻的理解了C++的虚函数机制。
之前没完全看懂的，现在我觉得又可以了，然后再回头看一次。
class A
{
public:
virtual int Test(){return 1;}
int _a;
};
class B: virtual public A
{
public:
virtual int Test(){return 2;}
int _b;
};
class C : virtual public A
{
public:
virtual int Test(){return 3;}
int _c;
};
class D : public B, public C
{
public:
virtual int Test(){return 4;}
int _d;
};
int main()
{
D *d = new D();
d->_a = 1;
d->_b = 2;
d->_c = 3;
d->_d = 4;
return 0;
}这是一个经典的菱形继承，再来看一下内存分布就比较清晰了：
(gdb) start
Temporary breakpoint 1 at 0x400666: file test.cpp, line 31.
Starting program: /tmp/test
Missing separate debuginfos, use: debuginfo-install glibc-2.17-326.el7_9.x86_64
Temporary breakpoint 1, main () at test.cpp:31
31 D *d = new D();
Missing separate debuginfos, use: debuginfo-install libgcc-4.8.5-44.el7.x86_64 libstdc++-4.8.5-44.el7.x86_64
(gdb) n
32 d->_a = 1;
(gdb)
33 d->_b = 2;
(gdb)
34 d->_c = 3;
(gdb)
35 d->_d = 4;
(gdb)
37 return 0;
(gdb) p *d
$1 = {<B> = {<A> = {_vptr.A = 0x400958 <vtable for D+88>, _a = 1}, _vptr.B = 0x400918 <vtable for D+24>, _b = 2}, <C> = {_vptr.C = 0x400938 <vtable for D+56>, _c = 3}, _d = 4}
(gdb) print sizeof(D)
$2 = 48
(gdb) x /16wa d
0x603010: 0x400918 <_ZTV1D+24> 0x0 0x2 0x0
0x603020: 0x400938 <_ZTV1D+56> 0x0 0x3 0x4
0x603030: 0x400958 <_ZTV1D+88> 0x0 0x1 0x0
(gdb) x /16wa 0x400918
0x400918 <_ZTV1D+24>: 0x400722 <D::Test()> 0x0 0x10 0x0
(gdb) x /16wa 0x400938
0x400938 <_ZTV1D+56>: 0x400731 <_ZThn16_N1D4TestEv> 0x0 0xffffffffffffffe0 0xffffffffffffffff
(gdb) x /16wi 0x400731
0x400731 <_ZThn16_N1D4TestEv>: sub $0x10,%rdi
0x400735 <_ZThn16_N1D4TestEv+4>: jmp 0x400722 <D::Test()>
(gdb) x /16wa 0x400958
0x400958 <_ZTV1D+88>: 0x400737 <_ZTv0_n24_N1D4TestEv> 0x0 0x400918 <_ZTV1D+24> 0x0
(gdb) x /16wi 0x400737
0x400737 <_ZTv0_n24_N1D4TestEv>: mov (%rdi),%r10
0x40073a <_ZTv0_n24_N1D4TestEv+3>: add -0x18(%r10),%rdi
0x40073e <_ZTv0_n24_N1D4TestEv+7>: jmp 0x400722 <D::Test()>
如前文所述，g++的实现是将虚函数表和虚基地址偏移量一起在虚表里，通过虚指针表明，虚基地址偏移量在虚表的最后一项。
详细内容可以看一下下面引用的百科。
https://www.sandordargo.com/blog/2020/12/23/virtual-inheritance
https://zh.wikipedia.org/zh-sg/%E8%99%9A%E7%BB%A7%E6%89%BF