<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Manistein&#39;s Blog</title>
    <link>//manistein.club:80/</link>
    <description>Recent content on Manistein&#39;s Blog</description>
    <generator>Hugo -- gohugo.io</generator>
    <managingEditor>1518986465@qq.com (Manistein)</managingEditor>
    <webMaster>1518986465@qq.com (Manistein)</webMaster>
    <lastBuildDate>Wed, 28 May 2025 12:13:41 +0800</lastBuildDate>
    
	<atom:link href="//manistein.club:80/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>操作系统构建Part9：PLIC外部中断响应机制</title>
      <link>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part9/</link>
      <pubDate>Wed, 28 May 2025 12:13:41 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part9/</guid>
      <description>&lt;h1 id=&#34;9-1-前言&#34;&gt;9.1 前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;本章将介绍dummyxv6的外部中断响应机制。dummyxv6是运行在RISC-V架构的处理器之上的教学级操作系统，其外部中断机制，主要依赖RISC-V的PLIC（Platform Level Interrupt Controller）来实现。本章首先会介绍PLIC响应外部中断的整体流程；然后在PLIC中断响应机制上，dummyxv6如何处理键盘按键事件，并输出到屏幕上；接着会介绍这些流程的实现代码。
&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>操作系统构建Part8：调度机制</title>
      <link>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part8/</link>
      <pubDate>Thu, 24 Apr 2025 12:16:22 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part8/</guid>
      <description>&lt;h1 id=&#34;8-1-前言&#34;&gt;8.1 前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;本章的内容，是介绍dummyxv6系统的调度机制。本章先会略过许多代码细节，从高层次阐述调度机制的流程，再展示dummyxv6支撑调度机制的其他细节。在本章配套的代码中，内核运行在只有一个CPU核心的虚拟设备上，内核初始化阶段会创建两个用户进程，这个用户进程将会运行一段无限循环指令，然后通过定时器中断来触发进程切换，最后实现任务调度机制。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>操作系统构建Part7：页表</title>
      <link>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part7/</link>
      <pubDate>Sat, 08 Feb 2025 16:23:11 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part7/</guid>
      <description>&lt;h1 id=&#34;7-1-前言&#34;&gt;7.1 前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;上一章读者们学习了dummyxv6的物理内存初始化流程，本章将进入新的章节，本章主要介绍虚拟内存和物理内存的概念，然后介绍虚拟内存和物理内存的映射流程，最后会引入页表的概念，以及dummyxv6如何实现页表功能。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>操作系统构建Part6：物理内存管理机制</title>
      <link>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part6/</link>
      <pubDate>Thu, 23 Jan 2025 16:26:21 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part6/</guid>
      <description>&lt;h1 id=&#34;6-1-前言&#34;&gt;6.1 前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;前面的章节介绍了dummyxv6内核的很多基础模块，本章要介绍的是内核的物理内存管理机制。物理内存，即是设备所持有的实际的内存，内核对物理内存进行统一管理，可以方便后续实现进程逻辑的时候的内存分配和回收，因此本章涉及的内容非常重要。现在将逐个章节开始介绍。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>操作系统构建Part5：自旋锁的设计与实现</title>
      <link>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part5/</link>
      <pubDate>Thu, 02 Jan 2025 15:32:25 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part5/</guid>
      <description>&lt;h1 id=&#34;5-1-前言&#34;&gt;5.1 前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;截止到上一章，dummyxv6实现的操作系统部分均是在单个核心内跑的逻辑。设想一下，printf函数会按格式要求输出参数到显示设备，这个操作在只有一个核心的CPU上运行是没有问题的，但是如果多个核心并行运行，那么比如hart0正在运行printf相关的指令的时候，hart1也开始执行printf相关的指令，那么hart0涉及的输出内容可能会掺杂hart1正在输出的内容，这显然不是我们想要的结果，为了保证输出操作的原子性，就需要引入锁的概念了。&lt;br /&gt;
&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>操作系统构建Part4：实现初版printf模块</title>
      <link>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part4/</link>
      <pubDate>Thu, 19 Dec 2024 10:30:08 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part4/</guid>
      <description>&lt;h2 id=&#34;4-1-前言&#34;&gt;4.1 前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;上一章阐述了必须在机器模式下执行的初始化操作，并且介绍了dummy-xv6的内核模块初始化是在main函数里执行的。main函数是在CPU的内核模式下运行的，而本章开始，会陆续往main函数里写入内核模块初始化相关的逻辑。&lt;br /&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;所有的一切，都要从输入输出开始，而输出则需要更早实现，因为没有输出，我们将无法高效率得获得反馈信息，这将极大降低读者们的调试效率。本章要实现的正是初版的printf模块，这个printf模块没有线程安全，因此本章对应的用例也只是在一个核下运行，笔者将在下一章实现自旋锁，然后再完善printf模块的线程安全机制。彼时，读者就能看到完整的内核级别的printf模块了。&lt;br /&gt;

&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;与IO设备进行通信，需要用到协议，比如UART协议、USB协议等。本章要介绍的是最简单的UART协议，虽然当今市场USB大行其道，但是UART协议还是广泛被使用的，本章首先会着重介绍UART协议的原理，像这种在内核实现的与输入输出设备交互的模块，也被称为驱动。&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>操作系统构建Part3：dummyxv6的初始化流程</title>
      <link>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part3/</link>
      <pubDate>Tue, 10 Dec 2024 15:14:15 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part3/</guid>
      <description>&lt;h2 id=&#34;3-1-前言&#34;&gt;3.1 前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;第二章详细讨论了RISCV架构的中断机制，本章将回过头来继续探讨第一章讲述的流程。本章的内容比较少，主要是介绍只能在机器模式下进行的初始化流程。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>操作系统构建Part2：操作系统的结构</title>
      <link>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part2/</link>
      <pubDate>Thu, 14 Nov 2024 21:52:00 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part2/</guid>
      <description>&lt;h2 id=&#34;2-1-前文回顾&#34;&gt;2.1 前文回顾&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;上一章，笔者带领大家迅速过了一下一个hello world程序的运行流程，然后粗略介绍了操作系统的概念和作用，接着介绍了dummy-xv6项目，以及RISC-V的通用寄存器和它的调用规范，最后介绍了怎么编译dummy-xv6项目。上一章读者们编译得出了一个名为kernel的可执行文件，细心的读者可能会问，这个kernel是否就代表操作系统？如果不是，它和操作系统是什么关系呢？本章将就操作系统进行更深入的探讨。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>操作系统构建Part1：初探</title>
      <link>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part1/</link>
      <pubDate>Tue, 29 Oct 2024 14:29:02 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/computer-system/let-us-build-a-os/%D1%9E%D0%B8part1/</guid>
      <description>&lt;h2 id=&#34;1-1-前言&#34;&gt;1.1 前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;在开始阅读本系列之前，读者们不妨先问自己几个问题？&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;你是否对操作系统的运作原理感兴趣？&lt;/li&gt;
&lt;li&gt;你是否阅读了很多资料，却仍然无法对操作系统形成系统性的认知？&lt;/li&gt;
&lt;li&gt;你是否试图尝试动手实践，手写一个简单的操作系统，却又无从下手？&lt;/li&gt;
&lt;li&gt;你是否感觉到，在研究实用的操作系统前，总是感到过于复杂，缺了一块前置的垫脚石？&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;如果你的回答都是否，那么你可能是一位操作系统专家，本系列并不适合你。如果上面的问题中，你有一个，甚至多个回答是“是”，那么不妨多了解一下这个系列。&lt;br /&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;这是笔者继《Lua解释器构建：从虚拟机到编译器》系列之后的新系列，《操作系统构建：从0实现xv6系统》，&lt;a href=&#34;https://github.com/mit-pdos/xv6-riscv&#34;&gt;xv6&lt;/a&gt;系统是美国麻省工程学院开发的一款面向教学的Unix Like操作系统，它旨在向学生展示一个完整而简单的操作系统原型，帮助学生理解操作系统的基本概念。&lt;br /&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;然而，从笔者创建的技术讨论社区来看，xv6尽管已经非常精简，但是对一些新人来说，研究起来还是有一些小费劲。对此，笔者应一部分粉丝的要求，和上一个系列一样，着手拆解xv6操作系统，一步一步实现它，并在原有基础上拓展图形界面，并实现两个能在这个操作系统上跑的小游戏。这个项目笔者将其称之为dummyxv6。&lt;br /&gt;

&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;dummyxv6是一个开源项目，它的地址位于&lt;a href=&#34;https://github.com/Manistein/dummy-xv6&#34;&gt;这里&lt;/a&gt;。欢迎广大读者点击这个链接，并star这个项目。在开始我们的旅程之前，读者需要下载一些软件，整个工程是在运行在Virtual Box上的Ubuntu Server系统上开发，并且在Ubuntu Server上实用QEMU进行运行，验证和调试。因此读者需要下载并安装如下软件：&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>深入理解ptmalloc的运作机制</title>
      <link>//manistein.club:80/post/program/c/%D1%8E%D1%8B%D1%8D%D1%82ptmalloc%D1%9E/</link>
      <pubDate>Tue, 04 Jun 2024 16:08:24 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/c/%D1%8E%D1%8B%D1%8D%D1%82ptmalloc%D1%9E/</guid>
      <description>&lt;h1 id=&#34;1-前言&#34;&gt;1、前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;一直对glibc的内存分配器的设计与实现感兴趣，之前一直没有下定决心以及抽出足够的时间进攻这个方向，最近抽出了几天对glibc的ptmalloc源码进行了梳理和研究，现在将研究成果梳理总结成文。&lt;br /&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;为什么要写这篇文章？相信很多读者对系统是怎样管理内存感兴趣，通过深入研究ptmalloc，读者可以深刻了解到系统是怎样减少内存碎片，如何提升多线程环境下的内存分配和释放的性能，这对读者更好地进行系统编程有着直接或间接的帮助。本文立足于glibc 2.26的源码，为了方便读者理解和方便笔者书写，着重介绍概念和运作原理，不会贴大段的代码，各位看官大可放心食用。最有本人水平有限，如有书写不当的地方欢迎大家联系我修改，欢迎大家加入技术讨论群：QQ185017593。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>分代GC浅析</title>
      <link>//manistein.club:80/post/program/garbage-collection/gc%D1%9E/</link>
      <pubDate>Sat, 13 Jan 2024 15:50:44 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/garbage-collection/gc%D1%9E/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;去年一年就出了一篇博客，整体上来说还是太忙了，又是赶项目又是忙出书的事情，趁着农历还没新年，忙里偷闲整一篇新的XD。本次想讨论的内容是分代GC（garbage collection，意为垃圾回收机制），关于GC相关的文章，之前在Lua解释器构建系列中已经出过一篇，不过那个是增进式GC（感兴趣的读者可以点击这个链接：&lt;a href=&#34;http://manistein.club/post/program/let-us-build-a-lua-interpreter/%E6%9E%84%E5%BB%BAlua%E8%A7%A3%E9%87%8A%E5%99%A8part2/&#34;&gt;构建Lua解释器Part2：Garbage Collection基础架构&lt;/a&gt;），本文想要讨论的则是分代GC。&lt;br /&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;虽然本文写作的动机是在笔者阅读完Lua 5.4的GC源码之后，出于巩固知识的目的写的，但是笔者还是希望从更高的层次去讨论GC算法本身，因此会略去诸多Lua虚拟机相关的实现细节。本文将从GC的作用开始论述，介绍GC机制中常见的组成部件。首先通过简单的标记清除算法来引入GC的概念，然后逐步引入分步执行GC的概念和算法，最后以Lua 5.4所使用的分代GC算法为例，介绍工业级语言虚拟机是如何进行分代GC运作的。&lt;br /&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;为了方便论述，本文不会完全遵循源码中的所有细节，旨在更好的解释分代GC这种机制，希望能让读者对分代GC有个比较深刻的理解，最后由于本人水平有限，如有不正确的地方，欢迎大家批评指正，笔者在此感激不尽。读者也可以加入笔者创建的Q群，QQ号为：185017593。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>MongoDB初探</title>
      <link>//manistein.club:80/post/server/db/mongodb%D1%97/</link>
      <pubDate>Sat, 28 Jan 2023 15:27:29 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/server/db/mongodb%D1%97/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;本篇内容是我阅读完MongoDB 4.2官方文档后的梳理总结，并且只是梳理。梳理的内容并不包含MongoDB官方文档的方方面面，更多的是与我们项目相关联的部分。本篇博客不是简单对官方文档的整理，其中包含了很多官方文档之外的资料，文章的脉络和结构，也是根据本人的理解进行组织。本文并不打算阐述太多MongoDB操作和部署相关的内容，更多的是梳理其内部的一些运作机制，如果想了解如何部署和使用MongoDB API，请查阅&lt;a href=&#34;https://www.mongodb.com/docs/v4.2/&#34;&gt;官网&lt;/a&gt;。&lt;br /&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;最后，由于本人水平有限，如有不当之处欢迎指出，同时也欢迎读者加入QQ:185017593群聊。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>红黑树探索</title>
      <link>//manistein.club:80/post/program/c/%D1%8C%D1%9E%D1%9E/</link>
      <pubDate>Sat, 29 Oct 2022 00:20:45 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/c/%D1%8C%D1%9E%D1%9E/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;在沉浸了一年多之后，我开始重新拾起了写博客的习惯。过去一年主要在忙我的书的事情，一本关于如何实现Lua解释器的书&amp;ndash;《Lua解释器构建：从虚拟机到编译器》。这本书将由机械工业出版社出版，目前已经过了终审，处于校对环节，预计明年1月能够出样书，大概2月份能够上市。随书源码已经放到github上了，有兴趣的读者可以点击&lt;a href=&#34;https://github.com/Manistein/let-us-build-a-lua-interpreter&#34;&gt;这里&lt;/a&gt;进行访问。由于我想写的内容已经在书中展现，因此原来的博客&lt;a href=&#34;https://github.com/Manistein/dummylua-tutorial&#34;&gt;dummylua-tutorial&lt;/a&gt;系列不再更新。&lt;br /&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;对书籍的预热结束，言归正传，本篇将深入探索红黑树。红黑树由于难于理解与实现，业内一直将“手撸红黑树”作为调侃的梗。本文将要探索的是红黑树的设计与实现，在开始写博客之前，我已经动手将红黑树实现了一遍，并且通过了预定的测试，确实是“手撸红黑树”了，XD。该项目我已经放到github上，读者可以通过这个链接&lt;a href=&#34;https://github.com/Manistein/red-black-tree&#34;&gt;red-black-tree&lt;/a&gt;进行下载。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part12：Weaktable</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart12/</link>
      <pubDate>Mon, 19 Jul 2021 17:43:18 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart12/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;本章我开始论述lua的弱表(weaktable)机制，到目前为止，我已经完成了弱表的设计和实现了，读者可以在&lt;a href=&#34;https://github.com/Manistein/dummylua-tutorial&#34;&gt;dummylua&lt;/a&gt;的对应章节目录，找到对应的代码工程。本章，我首先会介绍什么是弱表，它的用途，最后分别介绍弱键、弱值以及完全弱引用。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>探索libevent</title>
      <link>//manistein.club:80/post/server/libevent/%D1%9Elibevent/</link>
      <pubDate>Tue, 27 Apr 2021 18:16:53 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/server/libevent/%D1%9Elibevent/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;libevent是当前一个非常知名的跨平台网络库，学习并研究它，可以让我们理解一个优秀的网络库是如何设计的。为此，我近期花了几天时间，过了一遍libevent的基础数据结构和基本运行机制。虽然libevent库整体并不是很大，但是短短几天内要彻底掌握所有的细节，还是有相当的难度，因此这里，我只阐述libevent最核心的运作机制。本文研究的libevent的版本是libevent-2.1.12-stable。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part11：Upvalue</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart11/</link>
      <pubDate>Sat, 13 Mar 2021 10:01:07 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart11/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;本章，我将深入探讨lua的upvalue机制。在写这篇博客之前，我已经自己动手实现了这个机制，并且将其提交到了github仓库&lt;a href=&#34;https://github.com/Manistein/dummylua-tutorial&#34;&gt;dummylua&lt;/a&gt;上了。为了专注于upvalue机制本身的讨论，本章不会展示大量的代码细节，尽量在抽象层面来论述。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part10：userdata</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart10/</link>
      <pubDate>Tue, 23 Feb 2021 14:00:15 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart10/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;本章节，我开始对&lt;a href=&#34;https://github.com/Manistein/dummylua-tutorial&#34;&gt;dummylua&lt;/a&gt;的userdata的设计与实现，进行论述。它的大体设计与实现，仍然是仿照了lua5.3的标准，由于，所有的内容，都是我自己理解后，重新实现，因此在一些实现细节上略有不同，但是整体设计思路遵循了lua的设计思想。本章的篇幅不会很长，因为userdata这个部分并不是非常复杂，因此我这里也会速战速决，将userdata的一些核心思想论述清楚，就将本章完结。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part9：metatable</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart9/</link>
      <pubDate>Tue, 08 Dec 2020 16:03:32 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart9/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;本章，我们将进入到metatable的探索之中。由于这块本身比较简单，而且我也不打算罗列代码细节，因此本章的篇幅不会很大。只是对一些我认为比较关键的部分，进行说明。首先，本章的主要任务，首先是简要介绍metatable是做什么的，然后简要说明一下，它如何被设置，接着介绍metatable的访问域，双目运算操作域、单目运算操作域等。最后会告诉读者，本章的实现逻辑位于dummylua工程的哪些部位。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part8：构建完整的语法分析器(下)</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart8/</link>
      <pubDate>Wed, 04 Nov 2020 15:21:23 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart8/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;前面，我已经用3篇blog的巨大篇幅，详细论述了Lua编译模块的一些基本知识。其中，Part5通过一个简单的打印hello world的例子，论述了编译出来的虚拟机指令，如何存到Proto结构中，最后再通过虚拟机执行的流程。Part6详细论述了，词法分析器的设计与实现。而Part7则论述了，expression的编译流程。本章，将作为Lua内置编译器论述的最后一个部分。往后的部分，将不再涉及编译相关的内容。当然，经历这篇，相信读者能够完全理解Lua内置编译器的设计与实现，个人认为完整度还是比较高的。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part7：构建完整的语法分析器(上)</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart7/</link>
      <pubDate>Sat, 05 Sep 2020 09:25:56 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart7/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;在上一章里，我完成了词法分析器的设计与实现的论述，接下来我要继续论述语法分析器的设计与实现。限于篇幅，我将会把语法分析器分为两个部分来论述，本章为上部，下一章为下部。本章将会重新复习编译器的构造，并且论述编译流程，以及lua的parser所涉及的编译相关的内容，最后通过阐述虚拟机相关指令的实现，作为结尾。本章所涉及的代码，全部在&lt;a href=&#34;https://github.com/Manistein/dummylua-tutorial&#34;&gt;dummylua&lt;/a&gt;工程里，欢迎star。另外，如果你喜欢我写的文章，喜欢讨论技术，欢迎加入我创建的群：QQ185017593&lt;br /&gt;
&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part6：词法分析器设计与实现</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart6/</link>
      <pubDate>Sat, 22 Aug 2020 16:47:15 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart6/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;构建Lua解释器Part5，对Lua解释器进行了整体介绍，并且以一个hello world程序为例子，给读者一个初步的概念。通过那一篇，我们知道了编译器至少要包括词法分析其和语法分析器，而本篇，我将集中时间和精力，用来介绍和讲解Lua词法分析器的设计与实现，实际上，它是对Part5词法分析器部分的一个补充。本文所指的词法分析器，是参照Lua-5.3这个版本的源码，并且亲自动手实现和测试过，它也已经被整合到&lt;a href=&#34;https://github.com/Manistein/dummylua-tutorial&#34;&gt;dummylua&lt;/a&gt;这个工程中，欢迎大家star。由于整个词法分析是我自己重新实现，因此不会在所有的细节上和官方lua保持一致，最后由于本人水平有限，如有写的不正确的地方，欢迎大家批评指正。此外，我已经建了一个qq群(QQ:185017593)，有兴趣参与技术讨论的同学可以加进来。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>skynet网络机制</title>
      <link>//manistein.club:80/post/server/skynet/skynet%D1%87/</link>
      <pubDate>Sat, 29 Feb 2020 10:12:36 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/server/skynet/skynet%D1%87/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;我在前几年，写了一篇&lt;a href=&#34;https://manistein.github.io/blog/post/server/skynet/skynet%E6%BA%90%E7%A0%81%E8%B5%8F%E6%9E%90/&#34;&gt;《skynet源码赏析》&lt;/a&gt;，阐述了skynet的整体设计，和核心运作机制流程，该文针对的是skynet-1.0版本，如今skynet已经升级到1.3版本，总的来说，skynet整体架构并没有特别大的改动，不过从1.2版本开始，skynet增强了网络并发处理的能力。1.3改进了cluster机制，修复了一些大量并发可能导致的bug。尽管《skynet源码赏析》这篇，已经详细地阐述了skynet内部实现机制，不过对于网络部分，这篇只是阐述了大致的运作机理，并未深入源码层进行非常细致的分析，为了填补这个遗憾，我决定在近期新增一篇专门讲解skynet网络机制的blog，此外我还计划在未来几个月内，写一篇集群机制的blog，以此完成我所谓的“skynet源码剖析三部曲”，XD。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part5：脚本运行基础架构的设计与实现</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart5/</link>
      <pubDate>Thu, 06 Feb 2020 13:52:40 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart5/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;在经过漫长的准备，我终于完成了《构建Lua解释器》系列的第五部分的代码编写，并且通过了预定的测试。本篇我将对&lt;a href=&#34;https://github.com/Manistein/dummylua-tutorial&#34;&gt;dummylua&lt;/a&gt;项目中的脚本运行基础架构的设计与实现进行介绍和解析，它包括了lua编译器基础架构以及虚拟机基础架构。过去4个部分的开发，为本部分提供了坚实且必要的基础，本篇将为编译与运行lua脚本搭建最基础的架构，后续内容将在此架构上继续填充与丰富，本部分，我们的目标是编译并运行如下所示的一段脚本代码：&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>Understanding computer endianness</title>
      <link>//manistein.club:80/post/common/understanding_computer_endianness/</link>
      <pubDate>Wed, 30 Oct 2019 13:46:00 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/common/understanding_computer_endianness/</guid>
      <description>&lt;h1 id=&#34;preface&#34;&gt;Preface&lt;/h1&gt;

&lt;p&gt;After a long time, now I decide to add a new post. This is my first post written in English. Maybe it is a challenge, but it is surely a good beginning. I believe that one step at a time can make a thousand miles. I am going to talk about the endianness in this post.&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>C#服务端框架设计与实现</title>
      <link>//manistein.club:80/post/server/csharp/csharp%D1%91%D1%94%D1%88%D1%8B/</link>
      <pubDate>Thu, 18 Apr 2019 22:22:24 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/server/csharp/csharp%D1%91%D1%94%D1%88%D1%8B/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;在完成&lt;a href=&#34;https://manistein.github.io/blog/post/program/build-a-lua-interpreter/%E6%9E%84%E5%BB%BAlua%E8%A7%A3%E9%87%8A%E5%99%A8part4/&#34;&gt;构建Lua解释器Part4&lt;/a&gt;以后，我原计划是将业余时间投入到Lua虚拟机的研究之中。不过最近，我们项目希望服务端和客户端共享战斗逻辑，功能由客户端实现，借以降低开发联调的成本，而客户端主要使用C#语言，在确定客户端能够做到表现和逻辑分离以后，我们决定服务端也搭建C#战斗集群来运行战斗逻辑。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part4：Table设计与实现</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart4/</link>
      <pubDate>Mon, 25 Feb 2019 22:24:19 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart4/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;本篇我将对&lt;a href=&#34;https://github.com/Manistein/dummylua-tutorial&#34;&gt;dummylua&lt;/a&gt;中Table的设计和实现进行介绍和说明。本文的目的旨在梳理清dummylua项目Table的数据结构和运作流程，该部分深度参考了lua-5.3.4的Table设计与实现，由于所有的细节是我自己根据理解重新实现，因此不会在所有的设计细节上和官方lua保持一致，但是遵循了基本的设计思路。&lt;br /&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;Table是Lua语言中举足轻重的组成部分，掌握和理解它具有战略意义，这也是实现Lua虚拟机的基础所在，本文首先介绍dummylua项目Table的数据结构，然后在概念上介绍一些基本的操作流程，如创建、resize、查询、插入和迭代等操作。
&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part3：String设计与实现</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart3/</link>
      <pubDate>Fri, 01 Feb 2019 00:15:10 +3400</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart3/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&lt;a href=&#34;https://manistein.github.io/blog/post/program/build-a-lua-interpreter/%E6%9E%84%E5%BB%BAlua%E8%A7%A3%E9%87%8A%E5%99%A8part2/&#34;&gt;上一章节&lt;/a&gt;我介绍了&lt;a href=&#34;https://github.com/Manistein/dummylua-tutorial&#34;&gt;dummylua&lt;/a&gt;项目的gc的设计原理和实现方式，该部分我基本是仿造了官方lua-5.3.4的做法。本章节，我将为大家带来dummylua项目TString的设计实现讲解。和以往任何一篇一样，本篇我也是基本遵循lua-5.3的设计思想，但由于实现是我凭理解自己手动实现，因此不会在所有的细节上和官方lua保持一致。&lt;br /&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;任何一门语言都要支持字符串，lua也一样，本章将从lua string的数据结构开始阐述，然后深入其他细节进行阐述，并试图揭露这些设计的历史背景和原因，由于本人能力有限，如有不当之处想要指明，或是想和我一起讨论，欢迎加Q群与我讨论(QQ185017593)，我是群主，欢迎大家的到来。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part2：Garbage Collection基础架构</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart2/</link>
      <pubDate>Tue, 13 Nov 2018 00:05:25 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart2/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&lt;a href=&#34;https://manistein.github.io/blog/post/program/build-a-lua-interpreter/%E6%9E%84%E5%BB%BAlua%E8%A7%A3%E9%87%8A%E5%99%A8part1/&#34;&gt;上一篇&lt;/a&gt;我已经设计和实现了Lua解释器最基础的基本数据结构，实现了纯C函数在栈中的调用流程，以及保护模式调用函数等内容，今天要介绍的则是Lua解释器的GC基础架构。Garbage
Collection机制，可能是让人们听之不寒而栗的机制，都说GC很复杂，需要花费大量时间去消化和理解，那为什么要在本系列的第2篇就早早引入？做这个决定并非一时冲动之举，而是经过思考后而决定的。之前在阅读了云风大神翻译的《编程之魂》第7章&lt;sup&gt;[1]&lt;/sup&gt;，这篇关于对Lua设计者的访谈记录中，作者有这么说过：&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part1：虚拟机的基础--Lua基本数据结构、栈和基于栈的C函数调用的设计与实现</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart1/</link>
      <pubDate>Wed, 17 Oct 2018 11:07:24 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart1/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;从本篇开始，我们正式进入到Lua解释器的开发阶段（这是一个遵循Lua5.3标准的项目）。本篇并不直接接入到设计和实现语法分析器和词法分析器的阶段，而是先设计和实现Lua虚拟机的基础数据结构（包括Lua最基本的数据结构，如基本数据类型，表示虚拟机状态的global_State和lua_State结构，在函数调用中扮演重要角色的CallInfo结构等）以及设计和实现基于栈的C函数调用流程。这些都是理解后面虚拟机运作的基础。由于这是一个仿制项目，为了和官方版本做区分，就称之为dummylua，后面要称呼本项目时，一律用dummylua来表示。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>构建Lua解释器Part0：综述</title>
      <link>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart0/</link>
      <pubDate>Tue, 16 Oct 2018 09:26:50 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/let-us-build-a-lua-interpreter/%D0%B8lua%D1%82%D1%9Epart0/</guid>
      <description>&lt;h2 id=&#34;项目简介&#34;&gt;项目简介&lt;/h2&gt;

&lt;p&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;lua是一门精妙简洁，而功能强大的语言，学习和掌握它的核心机制有着重要的意义。这是一个仿制lua解释器的项目(参照的版本是Lua5.3)，我希望通过逐步实现lua解释器的各个部分，更加深刻地掌握lua的基本结构和运作原理。本项目将分为多个部分完成，并为每一个部分附上一篇博文为该部分的设计和实现进行解析。开发这个项目的目的，并不是做一个能用于生产环境的lua解释器，而是尝试追寻前辈的步伐，尽最大可能理解其设计lua语言的思路，理解其中的关键细节。这是一个探索原理的旅程，因此效率并不是本项目要考虑的关键因素。这里我遵循的是&amp;rdquo;FIRST  make  it  run, THEN make it run fast&amp;rdquo;&lt;sup&gt;[1]&lt;/sup&gt;的原则，先让它跑起来。整个系列暂时不包含GC部分，不过这些开发量也足以消耗我大量的时间和精力。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>关于sizeof的一些思考</title>
      <link>//manistein.club:80/post/program/c/sizeof%D0%B9/</link>
      <pubDate>Fri, 24 Aug 2018 16:02:45 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/program/c/sizeof%D0%B9/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;今天，我所在的技术群（qq185017593），讨论了sizeof的问题，聊得不亦乐乎，然而一个群友贴的代码，我感觉有一些漏洞，于是梳理了一下思路和知识点，特此记录一下。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>网络安全初探</title>
      <link>//manistein.club:80/post/network/%D1%87%D0%BB%D1%97/</link>
      <pubDate>Mon, 09 Jul 2018 11:39:15 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/network/%D1%87%D0%BB%D1%97/</guid>
      <description>&lt;h1 id=&#34;写在最前面&#34;&gt;写在最前面&lt;/h1&gt;

&lt;p&gt;&amp;emsp;&amp;emsp;网络安全是个很大的话题，它包括了网络加密、数据真实性认证、终端身份认证、防火墙等技术，而网络加密、数据真实性验证，终端身份认证，则是网络安全中的重要一环，学习和掌握它具有重要意义，通过学习网络安全的相关知识，有助于我们理解生活中一些关于网络安全方面的现象。这样也可以做到知其然，并且知其所以然。最近一段时间，我发现自己对这块的掌握并不牢靠，于是参阅了一些资料和论文，主要的参阅资料是《Computer Networking A Top-Down Approach》的第八章Secure In Computer Networks，也包含了多篇paper。本文主要阐述网络加密、数据验证、身份验证的一些基本知识，并不涉及网络安全的其他方面。由于本人水平有限，有不正确的地方，欢迎批评指正，最后原创不易，转载请注明出处。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>数据链路层漫谈</title>
      <link>//manistein.club:80/post/network/%D1%83/</link>
      <pubDate>Thu, 03 May 2018 10:04:15 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/network/%D1%83/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;　　数据链路层，负责网络上，两个节点之间的数据帧通信，是最贴近硬件的一层。掌握数据链路层的知识，对我们理解网络中的一些现象具有极大的意义。这篇Blog，首先会介绍数据链路层的作用，以及基本结构和基本运作流程；紧随其后，我们将探讨数据链路层的转发设备，以及不同的设备构建的局部网络，数据帧传输的基本运作流程；最后我们将介绍在广播Channel中使用的链路层协议（Multi-Access   Protocol）。本文的知识和观点主要来自于《Computer Networking A Top-Down Approach》一书，本Blog也将会大量引用该书的图文。&lt;br /&gt;
　　本Blog的主要功能是对数据链路层知识进行梳理，而非对Top-Down中Link-Layer这一章节的翻译，而是经过自己的梳理而写的文章。最后由于本人水平有限，如有不当的地方，欢迎大家批评指正，大家可以将建议或者意见发到我的邮箱中1518986465@qq.com。
&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>数据包在网络层中的传输</title>
      <link>//manistein.club:80/post/network/%D1%87%D1%83%D0%BB%D1%84/</link>
      <pubDate>Sat, 14 Apr 2018 00:58:00 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/network/%D1%87%D1%83%D0%BB%D1%84/</guid>
      <description>&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;

&lt;p&gt;好久没有写blog了，近一年来，不断在学习网络相关的东西，最近看了许多书籍和paper，觉得是时候该写一篇有关网络层相关的文章，来梳理一下自己所学的知识点。在写这篇文章之前，我大概看过《计算机网络（谢希仁著）》、《网络是怎样连接的》和《Computer Networking A Top-Down Approach》等几本书。早在刚开始决定学习一下网络原理之初，我选择了《TCP/IP详解 卷1》来看，不过结合个人的学习经历，相比于Top-Down，个人认为这本书其实并不适合刚入门的初学者看，它略过了太多的细节，相反《Computer Networking A Top-Down Approach》这本，不论在内容编排上，还是在内容阐述上都非常合理、清晰，循序渐进，对于想入门计算机网络的人来说，是绝佳的经典教程。&lt;br /&gt;
按照我自己的习惯，每经历一个阶段的学习，我就会进行一次知识的梳理和总结，今天写的这篇&lt;strong&gt;目的是通过阐述数据包在网络层中的流转，梳理网络层的整体结构，运作流程。最终串联各个知识点&lt;/strong&gt;。本文将通过3个数据包流转的例子（其中一个是在一个很小的局域网内的传输，一个是在AS内的传输，还有一个是跨AS的传输），来逐步展现网络层的基本组成成分，以及不同规模情况下的基本运作流程。网络层数据包协议主要有IPv4和IPv6两种，目前广泛运用的仍然是IPv4，为了解决IPv4地址耗尽的问题，专家们提出了IPv6。本文探讨的内容，主要针对IPv4，不对IPv6作深入探讨。&lt;br /&gt;
本文旨在梳理网络层的基本结构和运作流程，并不涉及到网络层的方方面面，文章也会大量引用《计算机网络》、《网络是怎样连接的》、《Computer Networking A Top-Down Approach》以及其他一些论文的论述和插图，最后本人学识水平有限，如有疏漏，欢迎大家批评指正。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>skynet源码赏析</title>
      <link>//manistein.club:80/post/server/skynet/skynet%D1%8B%D1%9E/</link>
      <pubDate>Wed, 16 Aug 2017 19:41:45 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/server/skynet/skynet%D1%8B%D1%9E/</guid>
      <description>&lt;h4 id=&#34;写在最前面&#34;&gt;写在最前面&lt;/h4&gt;

&lt;p&gt;skynet是目前使用比较广泛的服务端框架，虽然目前网上资料众多，但是从自己的学习和使用经历来看，缺乏能够让自己系统了解该框架底层机制的资料，这段时间，趁着自己有时间，阅读了skynet底层的一些代码，现在将自己理解的部分总结并记录下来，以备日后使用。本文旨在捋清skynet框架的结构和主要流程，并不会涉及skynet的方方面面，一些论述，我贴上了一些源码加以论证，并在引用的源码里加入了一些注释。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>《TCP/IP详解》数据链路层总结</title>
      <link>//manistein.club:80/post/network/%D1%83%D1%81/</link>
      <pubDate>Mon, 07 Aug 2017 13:27:45 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/network/%D1%83%D1%81/</guid>
      <description>&lt;h1 id=&#34;数据链路层概述&#34;&gt;数据链路层概述&lt;/h1&gt;

&lt;ul&gt;
&lt;li&gt;计算机网络的形成&lt;br /&gt;
计算机最初只是孤立的一个运算机器，随着业务需求的不断发展，单台孤立的计算机已经不能够满足我们的需求，因此人们把一个区域内的多台计算机连接成一个网络即局域网，然而这些小的网络并不能满足对计算机日益增长的需求，因此把不同的局域网连接成一个全球性质的网络，我们称之为互联网，互联网就是把不同的局域网通过路由器连接起来的网络。&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>计算机漫游</title>
      <link>//manistein.club:80/post/os/%D1%83/</link>
      <pubDate>Tue, 30 May 2017 08:49:00 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/os/%D1%83/</guid>
      <description>&lt;h4 id=&#34;overview&#34;&gt;Overview&lt;/h4&gt;

&lt;p&gt;我们的计算机能够运作起来，是我们将源代码编译成机器能够识别的二进制机器指令后，打包进可执行文件，并存入磁盘中。当我们运行一个程序的时候，首先会将磁盘内的二进制文件加载到内存中，然后通过CPU来解释和运行。为了能够做到，通过统一的方式使用不同型号的硬件，并且防止失控的程序滥用硬件资源，人们则通过操作系统来处理这些事情。此外操作系统还负责不同进程间的上下文切换，以实现多任务执行（分时调度不同的进程）。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>mutex lock，spinlock，rwlock和condlock的理解</title>
      <link>//manistein.club:80/post/os/mutex-lock%D0%B3%D0%BCspinlock%D0%B3%D0%BCrwlockcondlock%D1%8D%D1%82/</link>
      <pubDate>Mon, 03 Apr 2017 11:57:00 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/os/mutex-lock%D0%B3%D0%BCspinlock%D0%B3%D0%BCrwlockcondlock%D1%8D%D1%82/</guid>
      <description>&lt;h2 id=&#34;mutex-lock&#34;&gt;Mutex Lock&lt;/h2&gt;

&lt;h4 id=&#34;概述&#34;&gt;概述&lt;/h4&gt;

&lt;p&gt;互斥锁，一条线程加锁锁住临界区，另一条线程尝试访问改临界区的时候，会发生阻塞，并进入休眠状态。&lt;/p&gt;

&lt;h4 id=&#34;具体说明&#34;&gt;具体说明&lt;/h4&gt;

&lt;p&gt;假设一台机器上的cpu有两个核心core0和core1，现在有线程A、B、C，此时core0运行线程A，core1运行线程B，此时线程B使用Mutex锁，锁住一个临界区，当线程A试图访问该临界区时，因为线程B已经将其锁住，因此线程A被挂起，进入休眠状态，此时core0进行上下文切换，将线程A放入休眠队列中，然后core0运行线程C，当线程B完成临界区的流程并执行解锁之后，线程A又会被唤醒，core0重新运行线程A&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>《TCP/IP详解》运输层总结</title>
      <link>//manistein.club:80/post/network/%D1%84%D1%83%D1%81/</link>
      <pubDate>Mon, 27 Mar 2017 00:30:00 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/network/%D1%84%D1%83%D1%81/</guid>
      <description>&lt;h2 id=&#34;运输层协议公有特征&#34;&gt;运输层协议公有特征&lt;/h2&gt;

&lt;h4 id=&#34;应用进程之间的通信&#34;&gt;应用进程之间的通信&lt;/h4&gt;

&lt;ul&gt;
&lt;li&gt;两台主机之间的通信，实际上是两台主机上应用进程之间的通信&lt;/li&gt;
&lt;li&gt;主机上所有使用网络功能的应用进程，共享操作系统内核提供的网络通信功能&lt;/li&gt;
&lt;li&gt;因为操作系统上应用进程众多，因此为了将数据包准确交付给目标机器上的指定进程，因此需要通过端口号来区分不同的进程&lt;/li&gt;
&lt;li&gt;IP+Port能够将数据包发送到指定机器上的指定进程&lt;/li&gt;
&lt;li&gt;运输层位于内核通信服务的最高层，接收应用进程交付的数据包，同时将收到的数据包交付给应用进程&lt;/li&gt;
&lt;li&gt;IP层负责将数据包交付给目标机器，而运输层则负责将数据包交付给指定应用进程，部分运输层协议（如TCP协议）实现可靠数据交付，流量控制，拥塞控制和连接状态控制等。&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>《TCP/IP详解》网络层总结</title>
      <link>//manistein.club:80/post/network/ip%D0%BD%D1%89%D1%83%D1%81/</link>
      <pubDate>Sat, 25 Mar 2017 14:40:00 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/network/ip%D0%BD%D1%89%D1%83%D1%81/</guid>
      <description>&lt;h1 id=&#34;ip协议层概述&#34;&gt;IP协议层概述&lt;/h1&gt;

&lt;p&gt;通过数据包的目标IP地址，不断得找出通往该IP地址的路由器（下一跳路由器地址），并最终将数据包送到目标机器上的协议层。本质的功效是导航数据包去往目标机器。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>Git使用总结</title>
      <link>//manistein.club:80/post/tools/git/git%D1%81/</link>
      <pubDate>Thu, 11 Aug 2016 20:36:00 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/tools/git/git%D1%81/</guid>
      <description>&lt;h1 id=&#34;远程分支&#34;&gt;远程分支&lt;/h1&gt;

&lt;ul&gt;
&lt;li&gt;项目开发，需要使用版本控制器，来控制开发流程，一般有一台公用服务器用于存放远程分支&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>skynet开发环境部署</title>
      <link>//manistein.club:80/post/server/skynet/skynet%D0%BA%D0%B2%D1%91/</link>
      <pubDate>Sun, 01 Nov 2015 16:02:45 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/server/skynet/skynet%D0%BA%D0%B2%D1%91/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;skynet官方没有提供windows版本，而在windows上进行开发则往往能够给我们提供极大的便利，一般而言，我们本地进行开发需要安装虚拟机(或者真机上安装linux)，然后在虚拟机(或真机)内部署skynet进程。为了能够方便地进行开发，我们将采用sublime text编辑器，通过安装SFTP插件，来将我们的代码同步到虚拟机(或真机)上。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>Github使用TotoiseGit配置流程</title>
      <link>//manistein.club:80/post/tools/git/githubtotoisegit%D1%84%D1%9E/</link>
      <pubDate>Tue, 24 Feb 2015 07:55:00 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/tools/git/githubtotoisegit%D1%84%D1%9E/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;如何在Windows上对Github上的项目进行版本管理，我想TortoiseGit是个非常不错的选择，它极大简化了我们的操作流程，本篇文章将介绍如何实现使用TotoiseGit管理Github上的项目&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>变换矩阵推导</title>
      <link>//manistein.club:80/post/client/cg/%D1%84%D1%94/</link>
      <pubDate>Sat, 08 Mar 2014 12:49:00 +0800</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/post/client/cg/%D1%84%D1%94/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;

&lt;p&gt;注：这篇文章，最早发表在CSDN博客上&lt;a href=&#34;https://blog.csdn.net/Manistein/article/details/8994607&#34;&gt;https://blog.csdn.net/Manistein/article/details/8994607&lt;/a&gt;  后来CSDN博客弃用了，于是迁移到这里，以下是正文&lt;br /&gt;
大学这几年一直在学图形学方面的知识，积累了一些原理的知识，也作过一些总结，并用word文档的方式记录下来，因为懒，不想写到博客上，前几天由于自己的手提出了问题，大量的笔记大量遗失，还好台式上还储存着，现在发现记录在网络上是最安全的，还可以和别人讨论学习，下面是我以前做的一些总结，现在把它放在一起，供大家参考，如果有什么错误的地方，希望大家批评指正，菜鸟在此先谢过各位大神。&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;</description>
    </item>
    
    <item>
      <title>About Me</title>
      <link>//manistein.club:80/page/about/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/page/about/</guid>
      <description> 有朋自远方来，不亦乐乎 欢迎来到我的博客，我希望通过分享自己的一些想法，见解和总结来结识更多的朋友。希望更多热衷技术的小伙伴可以加入我创建的游戏技术讨论群QQ：185017593
关于  《Lua解释器构建：从虚拟机到编译器》一书作者。 广州某游戏公司服务端技术总监。  我的技能  熟悉skynet 熟悉cocos2dx 熟悉c/c++和lua  爱好  阅读 总结 RTS游戏忠实粉丝，也喜欢GTA系列的游戏  </description>
    </item>
    
    <item>
      <title>About me</title>
      <link>//manistein.club:80/page/_index2/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      <author>1518986465@qq.com (Manistein)</author>
      <guid>//manistein.club:80/page/_index2/</guid>
      <description>My name is Inigo Montoya. I have the following qualities:
 I rock a great mustache I&amp;rsquo;m extremely loyal to my family  What else do you need?
my history To be honest, I&amp;rsquo;m having some trouble remembering right now, so why don&amp;rsquo;t you just watch my movie and it will answer all your questions.</description>
    </item>
    
  </channel>
</rss>