Home on Ylin

code a TCP/IP(1)

Wed, 08 Jul 2026 06:23:27 +0000

找到一个不错的教程 -> Let’s code a TCP/IP stack, 1: Ethernet & ARP

这个教程是教你如何一步一步的从基础实现TCP/IP的协议，使用的是C语言，不过我没有仔细看多少，打算平时没事的时候就对着复现一下。

PWN(0)

Tue, 24 Mar 2026 14:23:35 +0800

好久没有学网安了，偶尔也要学一学，现在基本功也还算扎实。打算开始好好学一下pwn，和一些常见的漏洞利用，精进一下技术。顺便就当是给AI agents整理文档了。

一生一芯F3(1)

Mon, 19 Jan 2026 13:18:29 +0800

寒假报名了一生一芯的训练，作为对我这个学期的知识的一个补全，顺便学一些新的知识。为下个学期研究二进制安全做一点准备。这一部分就记录我在学习过程中的一些心得体会。就不再像往常一样讲的那么详细了，因为知识点在文档中给的很清楚，没必要再敲一遍。

树

Sat, 15 Nov 2025 16:03:54 +0800

打算系统性的学一下数据结构与算法，这个就相当于笔记做一下记录了。

树

二叉树

二叉树的基本单元是节点，每个节点包含值、左子节点引用和右子节点引用。我们可以用以下数据结构表示：

c4编译器回顾(1)

Tue, 28 Oct 2025 16:37:10 +0800

我们将尝试构建一个C语言的解释器，这个项目也是我C语言的大作业。现在回顾看来，当时对整个项目都是知其然不知其所以然，从现在的眼光来看，当时很多做法都是很稚嫩的。尤其是对于这个项目结构的理解也远远不足，所以打算重构一遍。

NJU_PA_STUDY(0)

Fri, 26 Sep 2025 19:33:39 +0800

这个学期抽取一部分课余时间用来完成NJU的PA实验，争取能做多少做多少。

第一篇先从环境配置开始，这里我使用的程序环境是WSL+Vscode。

PA0 Getting Source Code For PAs

拉取源码

由于我的git环境已经配置好了，所以直接在我的主目录下面clone文件内容就行了：

异常控制流(1)

Wed, 06 Aug 2025 10:49:30 +0800

异常

从处理器加电一直到断电，程序计数器始终执行着一个序列的指令。每次从一个指令到下一条指令的过渡被称为控制转移。而这个控制转移序列则被称为处理器的控制流。最简单的控制流是一个平滑的序列，由诸如跳转，调用，返回一类的指令造成的。这些指令都是必要的，使程序能根据程序内部状态做出反映。

初窥深度学习(1)

Tue, 05 Aug 2025 16:06:58 +0800

最近很流行这些，出于好奇，我也想知道这些技术背后的原理是什么。而且我感觉很多知识可能之后会用到，所以我打算浅浅的了解一下。最终的目标是实现一个手写数字识别的神经网络吧。试试看吧。

链接(1)

Mon, 21 Jul 2025 10:52:19 +0800

开始学习新的章节——链接。我们现在要研究在gcc调用的过程中，到底有哪些过程是被我们所忽略的，在编译的过程中它们又有着什么作用呢？

编译器驱动程序

我们以下面的这段代码为例，将以此来分析整个编译的过程

程序性能优化(1)

Sat, 12 Jul 2025 13:28:39 +0800

对于特定的程序而言，尤其是要长时间多次运行的程序而言，我们需要尽可能的优化他的效率。如计算效率，空间效率…大多数时候编译器会帮助我们完成这个工作，但是特定的场景中，我们需要自己实现程序的优化设计。

Y86-64处理器实现(1)

Tue, 17 Jun 2025 14:17:28 +0800

最近在看CSAPP的第四章，因为要记的东西比较多，所以整理一些东西帮助理解

Y86-64指令集体系结构

对于程序员可见的状态

Y86程序的每条指令都会对我们的处理器进行一些改变，我们把这个过程称之为状态的改变。这里我们需要能够知道对应的行为，使我们的状态发生了哪些变化。这些需要被观测的状态就是“对于程序员可见的状态”

写一个Linux调试器(1)

Thu, 08 May 2025 10:57:16 +0800

之前一段时间在研究Linux下的虚拟内存分布，还有一些比较细节的内容吧。现在打算更加深入了解这个内容，刚好看到了这篇教程，所以打算花一周左右的时间跟着学习一下，顺便做个简陋的翻译吧。这里我们使用的C++

虚拟内存——C字符串与proc

Mon, 28 Apr 2025 16:03:26 +0800

看到一篇很好的实验性质的文章，在这里学习复现一下：破解虚拟内存

使用环境：

Ubuntu 24.04 noble(on the Windows Subsystem for Linux
gcc
python3.12.3

虚拟内存

首先我们需要明确虚拟内存是什么？

我们的内存在物理地址上实际上并不是连续的，为了方便程序的运行和对内存的使用，我们在使用虚拟内存技术。将物理内存映射到虚拟内存中，这个过程是通过内存管理单元（MMU）进行的。同时，在实际的运行过程中，我们并不希望进程之间互相影响，所以我们需要将它们的内存空间隔离开来，所以在进程眼中，他们都是独占内存的。

使用Git(上)

Fri, 18 Apr 2025 19:15:09 +0800

朋友圈里看到同学用Git，觉得图形化还是很帅的。加上最近刚好有需求，所以就来系统的学习一下git的使用。

这里参考的教程是：简介 - Git教程 - 廖雪峰的官方网站

初始图形学(1)

Mon, 31 Mar 2025 20:22:56 +0800

最近对图形学比较感兴趣，虽然感觉找不到工作，但是帅，我花点时间学一下，刚好练习一下C++

输出一个图像

ppm

当我们启动一个渲染器时，我们需要一种方式来查看我们的图像。最简单的方式就是将它写入文件中，这里我们使用PPM格式（因为它比较简单）

十大排序算法

Sun, 09 Feb 2025 18:48:33 +0800

用Python感受十大排序算法，首先我们对这十个排序进行分类

十大排序算法：
	非线性时间比较类：
		交换类：
			冒泡排序
			快速排序
		插入类：
			直接插入排序
			希尔排序
		选择类：
			简单选择排序
			堆排序
		归并类#：
			归并排序
	线性时间排序：
		计数排序
		桶排序
		基数排序

非线性排序

冒泡排序

最经典的排序算法

算法小练(1)

Sun, 09 Feb 2025 13:47:52 +0800

四月份还是三月份有蓝桥杯的算法比赛，加上一直对算法感兴趣。所以从现在开始稍微学一下。

每天会坚持做几题吧，因为不知道哪些比较重要，我就主要记一些我认为重要的内容和算法

8086CPU_Learning(1)

Thu, 16 Jan 2025 21:06:46 +0800

搞了那么久的博客现在终于可以开始汇编语言的学习了

这里我用的教材是王爽老师的《汇编语言》，使用的环境是基于DOSBOX的模拟DOS环境

接下来开始正式的学习

code a TCP/IP(2)

Tue, 14 Jul 2026 08:33:09 +0000

上一章中我们实现了基本的ARP功能。但是仅限于回答ARP的请求包，我们还不能主动从虚拟网卡上向其他节点发送ARP的查询请求。同时我们也没有实现，对ARP映射关系的学习，即缓存功能。为了能够继续对IP层的学习，首先我们要做好数据链路层对上层的支持。

PWN(1)

Sun, 29 Mar 2026 10:32:02 +0800

上一篇中讲了学习PWN之前，讲了一些需要知道的基本原理。现在开始真实的还原并解析这些过程：

栈溢出(上)

以下示例均为32位环境且没有开启no-pie，64位需要参考x86-64的ABI

一生一芯F3(2)

Thu, 22 Jan 2026 21:47:08 +0800

接着学习F3的内容

整数的机器级表示

主要讲了原码、补码、反码，这些是计算机组成的基本知识，就不做过多赘述。

F3.6.1 搭建4位减法器

根据4位加法器的设计思路, 尝试在Logisim中通过门电路搭建一个4位减法器, 用七段数码管按十六进制显示减法器的两个输入和结果, 并用一个LED灯指示减法结果是否产生借位. 搭建后, 通过仿真检查你的方案是否正确.

平衡树

Mon, 17 Nov 2025 20:45:51 +0800

书接上回，接着研究一下AVL树。

AVL树

在二叉搜索树中，我们可以知道，在多次的插入和删除之后，二叉树的左右可能会失去平衡，从而导致退化成链表，在这样的情况下我们的算法的效率会从O(logn)退化到O(n)：

c4编译器回顾(2)

Wed, 29 Oct 2025 12:59:29 +0800

上一节中完成了对虚拟机的实现和初始化，还有指令集的定义，接下来就是对源文件的词法分析部分

词法分析

什么是词法分析

源文件的内容对于我们的解释器而言，本质上就是一系列ASCII字符串，是毫无意义的，我们需要通过语法分析将其解析为简单的指令，然后再执行。可是这样一来，这就使得语法分析的部分十分庞大。所以编译器一般会对整个过程进行前后端的分离。前端负责对源文件进行预处理，将其解析为一系列标识符流，如下：

NJU_PA_STUDY(1)

Sat, 27 Sep 2025 07:37:21 +0800

PA1 RTFSC

框架代码

由于NEMU-PA是一个很庞大的框架系统，所以要在其基础之上开发需要对框架代码进行熟悉。所以最重要的一步应该是阅读程序的源代码。在课件中，已经给出了相关代码的简要结构说明，按照标题简单理解即可：

虚拟内存(1)

Wed, 27 Aug 2025 16:50:33 +0800

总是听到诸如页表，分页机制一类的词汇，听起来让人感到十分的复杂。实际上这些都是涉及到虚拟内存相关的只是。一直以来对这一部分的知识都是望而生畏，现在好好来理解一下它：

初窥深度学习(2)

Sun, 17 Aug 2025 14:14:27 +0800

在上一篇博客中，我们完成了一个简单的前馈神经网络，完成了对根据身高体重对性别进行猜测的神经网络，以及对他的训练。但是我们不该止步于此，接下来我们将尝试编写一个RNN循环神经网络，并认识它背后的原理。

异常控制流(2)

Thu, 07 Aug 2025 11:53:06 +0800

系统调用错误处理

由于之后会用到大量的系统调用函数，我们需要做好错误处理，以便于查找问题。Uinx系统中的系统级函数遇到错误时会返回-1，并设置全局整数变量errno来表示错误类型。这个时候我们可以通过strerror()函数来返回和errno值相关联的错误。我们以处理fork()的错误为例：

链接(2)

Mon, 21 Jul 2025 20:08:23 +0800

接下来我们要探讨学习一下符号解析和重定位实现的原理。

符号解析

连接器解析符号引用，实际上就是将每个引用，和它输入的可重定位目标文件的符号表中的一个确定的符号定义关联起来。当局部符号的引用和引用定义在相同模块的时候，符号解析简单明了。编译器只允许每个模块中每个局部符号只有一个定义，因此编译器要确保它们又唯一的名字。

程序性能优化(2)

Tue, 15 Jul 2025 10:31:17 +0800

上次我们分别从简单的过程调用的优化到了机器级层面的关键路径优化。在此基础之上，我们可以尝试更进一步的优化。

循环展开

循环展开通过增加每次迭代计算的元素的数量，减少循环的迭代次数。它从两个方面改进了程序的性能：

Y86-64处理器实现(2)

Tue, 17 Jun 2025 16:59:16 +0800

我们已经基本了解了Y86-64的指令集和汇编的用法，现在我们要尝试模拟处理器的硬件行为。这里描述一个称为SEQ的处理器，我们了解它的使用过程，并尝试构建它。

写一个Linux调试器(2)

Thu, 08 May 2025 16:36:58 +0800

昨天写了一些基本的架构，写到一半我突然有很多灵感，为什么一定要按照教程的内容去做呢。我应该有自己的想法，而且我现在也有能力去实现，有错误也可以慢慢调试。再加上AI的帮助，我可以以这个教程为蓝本，学习各种知识。

使用Git(中)

Sat, 19 Apr 2025 16:52:27 +0800

上一篇中学习了基本的本地的版本控制，现在进一步的学习Git的使用。

远程仓库

现在我们需要找一个网站用来为我们提供Git仓库托管服务，这个网站叫做Github，这个网站为我们提供了Git仓库的托管服务，不过我们首先需要注册一个账号，这里我已经搞完了。

本地的Git仓库和Github仓库之间的传输时通过SSH设置的，所以我们需要设置：

初始图形学(2)

Tue, 01 Apr 2025 09:20:11 +0800

今天简单的学习一下相关类的定义和作用

Vec3类

图形程序中需要一些用于存储几何向量和颜色的类，这里的话我们设置一个最简单的，只需要三个坐标就够了。我们使用相同的类vec3来表示颜色、位置、方向、偏移。所以我们会为这个类声明另外两个别名point3和color,但是要注意，不要将一个point3添加到一个color中

KMP算法精读

Thu, 13 Feb 2025 21:05:54 +0800

这是第二遍学KMP算法，第一遍学习的过程中，对他的原理理解的是云里雾里。现在回过头来，深度学习一下KMP算法

首先我们要清楚什么是KMP算法？

KMP

KMP算法的优点相较于暴力匹配算法(BF)更有效率。这是因为KMP算法会利用每次匹配得到的已有的信息，来进行回溯。从而开始一次新的匹配。而暴力算法由于重复的匹配，其复杂度为 O(m*n)；KMP算法的主串指针始终向前，所以复杂度为 O(m+n)

算法小练(2)

Thu, 13 Feb 2025 11:52:36 +0800

继续算法的日常练习

字符串

最大公共前缀

数组和字符串 - LeetBook - 力扣（LeetCode）全球极客挚爱的技术成长平台

编写一个函数来查找字符串数组的最大公共前缀；如果不存在，则返回 ""

8086CPU_Learning(2)

Fri, 17 Jan 2025 11:31:51 +0800

昨天我们学习了简单寄存器的使用和DEBUG程序的使用

这一篇我们将学习 寄存器的内存访问

寄存器（内存访问）

从访问内存的角度认识学习寄存器i

我们知道一个字的存储分为高字节和低字节，由于内存地址是自上而下向下递增的，所以高位字节从内存分布上看再地位字节的下面

PWN(2)

Wed, 08 Apr 2026 15:52:17 +0800

上一章中讲了栈溢出，我们发现大多数时候的攻击，要求我们知道/泄露出某个关键部分的地址，以掌握一定的内存布局和关键的注入点。为了更好的泄露内存信息，我们需要学习一个关键漏洞——字符串格式化漏洞。

一生一芯F4(3)

Thu, 29 Jan 2026 14:16:06 +0800

F4 计算机系统的状态机模型

处理器的组成和工作原理

F4.1.1 继续执行上述指令

尝试继续执行指令, 记录寄存器的状态变化过程. 你发现执行到最后时, 处理器处于什么样的状态? 上述数列的求和结果在哪个寄存器中?

堆

Tue, 18 Nov 2025 15:07:44 +0800

学一种新的数据结构——“堆”，但是貌似和底层原理中的堆并不一样。之前总是略有耳闻，但是一直都很少仔细去了解。

堆

堆是一种满足特定条件的完全二叉树，根据性质可以分为两种类型：

c4编译器回顾(3)

Thu, 30 Oct 2025 16:26:49 +0800

我们完成了对词法分析的获取函数next()，现在我们尝试根据token分析，和我们的语法规则，进行简单的语法分析。

解析变量

我们的解释器的语法结构，可以用下面的EBNF的表示法直观的体现：

makefile基本使用

Tue, 21 Oct 2025 16:27:29 +0800

MAKEFILE教程

之后要尝试做一些项目，在加上前一段时间接触PA，发现自己对自动构建项目一类的操作实在是一知半解，而且之后也需要要尝试自动化编译一些大型的源码，所以学习一下makefile的基本使用，完善一下自己对工具链的认知。这里我看的教程是廖雪峰的makefile入门

NJU_PA_STUDY(2)

Sun, 28 Sep 2025 09:34:21 +0800

NEME是一个用于执行其他用户程序的虚拟计算机，对于运行在NEMU中的应用程序，外部的调试器难以获取其详细的信息，往往需要对引用程序内部下断点的方法来观察程序运行。

虚拟内存(2)

Thu, 28 Aug 2025 12:30:27 +0800

我们已经学习了虚拟内存的作用和虚拟内存的基本使用过程，为了进一步的深入的理解虚拟内存的机制，我们需要要深入理解虚拟内存的基本原理。

地址翻译

现在我们将从底层除出发，理解硬件在虚拟内存中的角色。为了简化之后的说明，这里提前展示我们所要用到的符号以参考：

初窥深度学习(3)

Mon, 25 Aug 2025 11:07:52 +0800

上一篇文章中我们学习了循环神经网络，我们现在已经基本理解了神经网络怎么去处理数据/序列。可是对于图片、音频、文件之类的数据，我们该怎么去处理呢？相较于数据、序列，对图片使用传统神经网络会导致更大的开销。其他的数据类型也是同理，所以接下来我们将要认识卷积神经网络。

异常控制流(3)

Wed, 13 Aug 2025 13:08:39 +0800

信号

我们已经认识到了操作系统怎么通过异常使得进程上下文切换，以实现异常控制流的实现。现在我们将尝试另一种实现——Linux信号，来允许进程和内核中断其他的进程。

链接(3)

Sat, 26 Jul 2025 19:10:01 +0800

介绍完了目标文件是怎么链接到可执行程序的，我们不妨进一步学习可执行程序是怎么被加载到内存中并运行的。以及动态链接库是怎么和程序一起被加载的。

可执行目标文件

我们已经学习了链接器是怎么将多个目标文件合并成一个可执行目标文件的。我们的C程序，从一开始的一组ASCII文本文件，被转换成了一个二进制文件。这个二进制文件包含加载程序到内存并运行它所需的所有信息。一个典型的ELF可执行文件有以下内容：

程序性能优化(3)

Tue, 15 Jul 2025 13:23:20 +0800

我们已经尽可能的实现各种程度的优化了，但所谓知己知彼，百战不殆。我们不仅要了解程序的性能怎么去优化，同时也要了解制约程序进一步优化的因素是什么。

二分查找

Fri, 11 Jul 2025 10:47:05 +0800

开始算法的简单学习，今天先从二分查找法开始

二分查找

代码实现：

int binary_search(int start,int end,int key){
 int ret = -1;
 int mid;
 while (start <= end){
 mid = start + ((end - start) >> 1);
 if(arr[mid] < key)
 start = mid + 1;
 else if(arr[mid] > key)
 end = mid - 1;
 else{
 ret = mid;
 break;
 }
 }
 return ret;
}

这个是常用的二分法的代码实现，但是在这里我们仍然有很多要注意的地方：

Y86-64处理器的实现(3)

Sun, 29 Jun 2025 10:27:45 +0800

我们把之前的SEQ结构已经实现了，可是为了更好的符合流水线执行的特性，为我们需要对顺序的SEQ处理器做一点小的改动，我们需要将PC的计算拿到取指阶段。然后在不同的阶段之间留下流水线寄存器来保存状态。

写一个Linux调试器(3)

Sat, 10 May 2025 15:34:51 +0800

上次把断点基本的设置搞完了，接下来需要进一步的对寄存器进行操作。我们将添加读取和写入寄存器和内存的功能，这样我们就可以操作程序寄存器(PC)，从而实现程序状态的观察和操作。

初始图形学(3)

Thu, 03 Apr 2025 12:45:45 +0800

昨天休息了一天，今天继续图形学的学习

向场景发射光线

现在我们我们准备做一个光线追踪器。其核心在于，光线追踪程序通过每个像素发送光线。这意味着对于图像中的每个像素点，程序都会计算一天从观察者出发，穿过该像素的光线。并且计算这个光线的方向上所看到的像素的颜色。其步骤为以下几点：

算法小练(3)

Fri, 28 Feb 2025 12:48:54 +0800

简单结束了数组和字符串的学习，现在来继续学习哈希表的内容

设计哈希表

设计哈希集合

哈希表精讲 - LeetBook - 力扣（LeetCode）全球极客挚爱的技术成长平台

不使用任何内建的哈希表库设计一个哈希集合（HashSet），实现 MyHashSet 类：

8086CPU_Learning(3)

Fri, 17 Jan 2025 18:02:31 +0800

今天晚上的学习任务是用汇编写一个可执行程序，接下来开始吧

第一个程序

一个源程序从写出到执行的过程

编写汇编原程序

产生一个存储源程序的文本文件
对源程序进行编译连接

先使用汇编语言编译程序对源程序进行编译，产生目标文件；再用连接程序对目标程序进行连接，生成可在系统中运行的可执行程序
可执行程序包含两部分内容：
- 程序(从源程序中的汇编指令翻译过来的机器码)和数据(源程序中定义的数据)
- 相关的描述信息(比如，程序有多大，要占用多少内存空间)
执行可执行文件中的程序

在操作系统中，执行可执行文件中的程序

一生一芯F5(4)

Thu, 29 Jan 2026 15:58:44 +0800

F5 支持数列求和的简单处理器

我们已经学会了基本的数字电路逻辑和状态机的思想，现在我们要着手实现一个简单的处理器。首先我们需要明确接下来要实现的指令集sLSA和处理器的细节：

图

Sat, 22 Nov 2025 11:15:14 +0800

今天接着来认识一下图，结束了图的学习，数据结构的部分就告一段落了。之后就是涉及到一些基本的算法问题，感觉也会越来越难。

图

认识图

和之前的数据结构不同，图是一种非线性的结构，由顶点和边组成，以下面为例，我们可以将图G抽象的表示成一组顶点和一组边的集合：

c4编译器回顾(4)

Tue, 04 Nov 2025 15:23:50 +0800

在上一章中，我们完成了对函数体的解析，现在我们需要进一步解析函数体中的语句，还有程序中的表达式。我们需要将程序中的语句解析成我们的虚拟机能直接执行的语句，所以这一章中会有一点难度：

NJU_PA_STUDY(3)

Mon, 29 Sep 2025 12:14:57 +0800

我们先前反复提到了一个式子EXPR，它代表着表达式含义，常见的表达式是通过操作符连接的。这里我们需要为我们的框架实现一个表达式求值的功能。我们要解决的问题是求值一个字符串表示的表达式。

虚拟内存(3)

Sat, 30 Aug 2025 09:11:03 +0800

上一篇中我们研究了虚拟内存在理想状态下的工作模式，现在我们要结合实际案例，来进一步了解虚拟内存在具体环境下是怎么工作的：

Intel Core7/Linux内存系统

Core i7地址翻译

我们的系统是一个运行Linux的Intel Core i7。下图是其处理器的一个封装结构：

初窥深度学习(4)

Tue, 26 Aug 2025 13:33:07 +0800

我们先前实现了卷积神经网络的各层，以及基本的前向传播，现在我们要进一步的完善整个神经网络，通过反向传播实现对权重的更新，从而提高神经网络的准确性。

链接(4)

Fri, 01 Aug 2025 10:29:32 +0800

在上一章中的加载过程中，我们大致了解了动态链接的过程，接下来我们要进一步认知其背后的原理。

位置无关代码

共享库的主要目的就是让多个正在运行的进程共享内存中相同的库代码，从而节约内存空间。可是多个进程是怎么共享同样一个副本的呢？

存储器层次结构与性能利用

Fri, 18 Jul 2025 20:13:30 +0800

我们学习一下现代计算机中的存储器架构，以及它的一些具体实现。我们该如何利用存储器的性能来实现对局部性的高效利用？它背后的原理又是什么呢？

存储器存储结构

不同的存储器有着不同的存储技术和存储性能，可喜的是，它们的属性很好的互相补齐各自的不足，利用这个性质，出现了一种组织存储器系统的方法，称之为存储器层次结构。

螺旋矩阵

Wed, 16 Jul 2025 13:02:33 +0800

螺旋矩阵题型总结。我刷了几道螺旋矩阵相关的题目，这里我们介绍一下一些常见的解法。

螺旋矩阵

方形矩阵

当我们遇到n*n的方形矩阵时，可以用一种特殊的解法来遍历实现，以下面这道题为例：

Y86-64处理器的实现(4)

Mon, 07 Jul 2025 13:53:36 +0800

接着上一次的内容，中间有一段时间在忙着搞大作业的内容，所以就没继续搞这个了。今天我们将具体实现Y86-64的设计。

异常处理

异常控制流导致程序正常的执行流程被破坏掉。异常可以有程序内部产生，也可以由某个外部中断产生。我们的指令集主要包括三种类型：

写一个Linux调试器(4)

Wed, 14 May 2025 19:13:59 +0800

上一部分中我们实现了对于程序的汇编级别的调试，但是这种调试，过程繁琐，难度大，且调试过程的可读性较差。我们需要拓展我们的调试器的性能，所以我们需要用到DWARF格式以实现源码级别的调试。

旋转立方体

Sat, 05 Apr 2025 11:17:18 +0800

看到一个视频，对其内容比较感兴趣，刚好今天没什么事，我们来深入解析一下这个项目

视频链接：终端字符旋转立方体

参考链接：Donut math: how donut.c works

这是我们最终想要实现的效果（一个旋转的立方体）：

8086CPU_Learning(4)

Sat, 18 Jan 2025 10:03:43 +0800

为了进一步的使用对内存单元进行灵活的操作，所以使用 [BX]和loop指令对其进行操作

[BX]和loop指令

在开始学习之前，需要对一些符号进行讲解

[bx]和内存单元的描述

要完整的描述一个内存单元，需要两种信息：
- 内存单元的地址
- 内存单元的长度（类型）
这里[bx]表示一个内存单元，段地址默认为ds，偏移地址存储在bx中
loop

loop在英文中有循环的含义，所以这个指令肯定和循环有关，我们在后面进行详细的说明
我们定义的描述性的符号："( )"

为了描述上的简洁我们用一个描述性的符号"()“来表示一个寄存器或者一个内存单元中的值

现在我们可以把[bx]的物理地址表示为((ds)*16+(bx))

“(X)“所表示的数据有两种类型：1）字节；2）字数据类型由寄存器名称或者具体的运算决定
约定符号idata表示常量

之前我们说在”[…]“里用一个常量0表示内存单元的偏移地址，现在我们可以把所有常量都作为[idata]

一生一芯F6(5)

Thu, 19 Feb 2026 22:19:51 +0800

拖了大半个月，终于重新开始了一生一芯计划的学习。接下来要完成的部分是，一个有趣的项目

F6 功能完备的迷你RISC-V处理器

我们先前实现的简单的ISA只能实现一些简单的命令，但是并不具有完备性，导致很多功能我们难以正常实现，所以这一次我们要实现的是一个功能完备的RISC-V处理器，不过在此之前，我们需要更加深入的了解它。

NJU_PA_STUDY(4)

Thu, 02 Oct 2025 21:01:08 +0800

这一篇博客中,我将完成PA1的收尾部分，我将完成完成对表达式求值的功能拓展，和程序监视点的实现，预计要花费较多的时间。可能很多内容也需要好好学习理解一下。

初始图形学(4)

Sat, 05 Apr 2025 21:13:42 +0800

学到一半区研究旋转立方体去了，确实好玩，受益匪浅啊，刚好搞明白了上一章相机的设置和视图的投影，现在继续学习。

添加一个球

我们现在向我们的光线追踪器中添加一个物体。我们从添加一个球体开始（因为它是最容易分析实现的）

8086CPU_Learning(5)

Tue, 21 Jan 2025 21:01:39 +0800

DEBUG的用法

在 DOSBox 中使用 DEBUG 工具时，可以使用以下命令及其用法，这些命令主要用于调试汇编语言程序、查看和修改寄存器与内存内容、执行代码等。以下是 DEBUG 的所有常用命令及其详细用法：

一生一芯E4(1)

Tue, 10 Mar 2026 21:52:52 +0800

E阶段前面几部分的学习主要是在铺垫，从E4开始就有点上强度了，所以从此开始记录。

从C代码到二进制程序

Linux中的C语言进阶学习

在Linux中完成Learn C the hard way练习0~~22, 练习24~~25, 练习27~33, 你需要将示例代码拷贝到Linux中编译并运行, 结合文字RTFSC理解示例代码, 并完成相应的附加题.

初始图形学(5)

Sat, 05 Apr 2025 23:07:57 +0800

感觉学的还是有点慢啊，刚刚往后看了一点，感觉后面的知识越来越难，我得赶快点学。

法向量和多物体处理

根据法向量进行表面着色

我们需要计算出表面法线进而进行着色。（法线是垂直于交点处的表面的向量）

8086CPU_Learning(6)

Wed, 22 Jan 2025 19:00:12 +0800

今天继续学习汇编语言

转移指令的学习

jmp指令

使用jmp指令需要给出两种信息：

转移的目标地址
转移的距离（段间转移，段内转移，段内近转移）

根据位移进行的jmp指令

先对两种jmp进行介绍：

jmp short 标号

功能为：（IP）=（IP）+ 八位位移（short指明）

一生一芯E4(2)

Sat, 14 Mar 2026 20:30:52 +0800

预处理

预处理属于正式编译之前的步骤, 其本质是文本处理. 通常有以下工作：

头文件包含
宏替换
去掉注释
连接因断行符(行尾的\)而拆分的字符串
处理条件编译#ifdef/#else/#endif
处理字符串化操作符#
处理标识符连接操作符##

我们可以通过-E作为编译器选项，来获取预处理结果

初始图像学(6)

Mon, 07 Apr 2025 22:35:58 +0800

Camera类

我们之前学了很多的图形学知识和相关的程序，现在我们停下脚步，来好好整理一下我们学习的内容，我们将之前的视口代码和渲染代码合并到一个新的单类camera.h，这个类主要负责两项任务：

8086CPU_Learning(7)

Thu, 23 Jan 2025 12:55:34 +0800

今天继续学习汇编语言，感觉有点难哇

标志寄存器

我们前面介绍了13种寄存器分别的作用，现在还剩一种特殊的寄存器，它有以下功能：

用来存储相关指令的某些执行结果
用来为CPU执行相关指令提供行为依据
用来控制CPU的相关工作方式

这种特殊的寄存器被称为 标志寄存器（flag）

一生一芯E4(3)

Tue, 17 Mar 2026 20:30:52 +0800

手册行为和编码规范

这一部分我就不过多赘述，比较偏概念

E4.4.1 体验未指定行为

尝试在你的系统中编译运行上述程序, 观察程序的结果.

#include <stdio.h>
void f(int x, int y) {
 printf("x = %d, y = %d\n", x, y);
}
int main() {
 int i = 1;
 f(i ++, i ++);
 return 0;
}

[21:12:30] Ylin@Ylin /home/Ylin/programs/C
> gcc test.c
[21:12:39] Ylin@Ylin /home/Ylin/programs/C
> ./a.out
x = 2, y = 1
[21:12:41] Ylin@Ylin /home/Ylin/programs/C
> clang test.c
test.c:7:7: warning: multiple unsequenced modifications to 'i' [-Wunsequenced]
 7 | f(i ++, i ++);
 | ^ ~~
1 warning generated.
[21:12:52] Ylin@Ylin /home/Ylin/programs/C
> ./a.out
x = 1, y = 2

E4.4.4 体验未定义行为

尝试在你的系统中编译并多次运行上述程序, 观察程序的结果.
#include <stdio.h>
int main() {
 int a[10] = {0};
 printf("a[10] = %d\n", a[10]);
 return 0;
}

初始图形学(7)

Tue, 08 Apr 2025 11:46:20 +0800

上一章完成了相机类的实现，对之前所学的内容进行了封装与整理，现在要学习新的内容。

抗锯齿

我们放大之前渲染的图片，往往会发现我们渲染的图像边缘有尖锐的"阶梯"性质。这种阶梯状被称为"锯齿"。当真实的相机拍照时，边缘通常没有锯齿，这是因为真实的边缘时前景和背景颜色的混合，而不是简单的二值化。而且真实的世界是连续的，而我们渲染的图像是离散的，也就是说真实世界具有无限的分辨率，而我们的=图像的分辨率是有限的。我们可以通过对每个像素进行多次采样并取平均值，来近似实现此效果。

8086CPU_Learning(8)

Fri, 24 Jan 2025 13:05:50 +0800

今天继续学习汇编语言，争取这个星期之内学完8086CPU

内中断

CPU 具有一种能力，可以在执行当前的命令之后，检测到从CPU外部发送过来的或者内部产生的一种特殊信息，并且可以立即对接受到的信息进行某种处理。这种特殊的信息，我们称之为"中断信息"。中断的意思是要求CPU马上进行某种处理，并向需要进行处理的提供了必备的参数的通知信息

一生一芯E5(4)

Sat, 21 Mar 2026 11:30:52 +0800

从RTL代码到可流片版图

RTL仿真(Simulation) - 功能验证

先前我们分别实现了门电路和指令模拟的仿真，现在我们需要进一步的进行RTL的仿真。我们需要通过RTL仿真检查RTL代码所描述的电路功能是否符合预期。

初始图形学(8)

Thu, 10 Apr 2025 13:08:40 +0800

中途歇了一段时间写物理作业，然后昨天学了下垃圾回收。现在继续开始我们的图形学学习。

漫反射材质

现在我们有了物体和每个像素的多个光线，现在我们可以尝试制作更加逼真的材质了。我们先从我们的漫反射材质开始（也称为哑光材质）开始。不过这里我们将几何体和材质分开使用，这使得我们可以将一种材质应用于多种物体，或者将多种材质应用于一种物体。这样分开使用的方法更加灵活也更加容易拓展，所以我们选择这种方式来实现我们的材质。

8086CPU_Learning(9)

Sat, 25 Jan 2025 10:10:00 +0800

昨天学的那个太难了，再加上下午一直在玩，今天要赶赶进度

int 指令

当CPU执行 int n指令时，相当于引发一个n号中断的过程，其执行流程如下：

取中断类型码n
标志寄存器入栈，IF = 0，TF = 0
CS，IP入栈
(IP) = (n*4) (CS) = (n*4+2)

可以在程序中使用int指令，调用任何一个中断的中断处理程序

初始图形学(9)

Fri, 11 Apr 2025 09:42:39 +0800

继续图形学的学习，我打算在下一周左右结束图形学的学习，因为要期中考试了（晕），现在赶赶进度

金属

一个材质的抽象类

如果想让不同的物体拥有不同的材质，我们可以设置一个通用的材质类，具有许多参数。或者我们可以有一个抽象的材质类，封装特定材质的独特行为，这里我们使用第二种方式，因为这样便于我们更好的组织代码，设置这么一个类，对于不同的材质，我们需要做两件事：

8086CPU_learning(10)

Thu, 30 Jan 2025 08:23:28 +0800

马上过年了，这几天要么在帮忙，要么在玩。今天是年三十，上午没什么事，我要好好学一下。

外中断

外中断信息

有一种中断信息，来自于CPU的外部，当CPU外部有需要处理的事情发生的时候。比如说，外设的输入到达，芯片会向CPU发出相应的中断信息。CPU在执行完当前的指令后，可以检测发送过来的中断信息，引发中断过程，处理外设的输入

初始图形学(10)

Fri, 11 Apr 2025 20:15:48 +0800

继续冲

介电质材料

乍一听可能感觉很厉害，但实际上水，玻璃，钻石一类的材料都属于介电质，他们通常有以下特点：

不导电：但会光会与该材料发生相互作用，主要表现有反射与折射
折射率：是材料特有的属性，决定光线进入材料时的弯曲程度，不同的材料有不同的折射率

当光线击中他们时，会分成反射光线和折射（透射）光线。我们将通过随机选择的反射换和折射来处理这个情况，并确保每次交互只生成一个光线。

8086CPU_Learning(11)

Thu, 30 Jan 2025 22:31:35 +0800

这几天一直在玩，要抓紧学完，去学别的东西哦

直接定址表

学习如何有效的组织数据，以及相关的编程技术

描述了单元长度的标号

我们先以一个程序为例

assume cs:code 
code segment
 a: db 1,2,3,4,5,6,7,8
 b: dw 0
start:
 mov si,offset a
 mov bx,offset b
s:
 mov al,cs:[si]
 mov ah,0
 add cs:[bx],ax
 inc si
 loop s
 mov ax,4c00H
 int 21h
code ends
end start

这里的 a b start s code都是标号。这些标号仅仅表示了内存单元的地址

初始图形学(11)

Sun, 13 Apr 2025 10:50:28 +0800

今日收官之战，图形学之旅差不多到此为止了

可定位相机

我们的相机目前是固定视角的，比较单调。由于程序的复杂性，所以在这里我们最后实现它。首先，我们需要为我们的相机添加视场(fov)效果。这是从渲染图像一边到另外一边的视觉角度。由于我们的图像不是正方形视图，所以水平和垂直的fov是不同的。这里我们选择开发垂直fov。我们用度数来指定它，然后再构造函数中将其转换为弧度。

8086CPU_Extra(12)

Sat, 01 Feb 2025 13:03:36 +0800

这里我们接下来使用TurboC2来尝试编写可执行程序，它是一个可以在DOS十六位上运行的C语言编辑器，我们使用C语言来进一步的对8086进行学习

初始图形学(12)

Sun, 13 Apr 2025 15:27:07 +0800

两个星期过去了，我们的图形学入门之旅也是迎来了终章。

最后就以一个完美的作品来作为纪念我们图形学学习的短暂结束。

我们设置main函数：

#include "rtweekend.h"

#include "camera.h"
#include "hittable.h"
#include "hittable_list.h"
#include "material.h"
#include "sphere.h"

int main(){
 hittable_list world;

 auto ground_material = make_shared<lambertian>(color(0.5,0.5,0.5));
 world.add(make_shared<sphere>(point3(0,-1000,0),1000,ground_material));

 for(int a = -11;a < 11;a++){
 for(int b = -11;b < 11;b++){
 auto choose_mat = random_double();
 point3 center(a + 0.9*random_double(), 0.2, b + 0.9*random_double());

 if((center - point3(4,0.2,0)).length() > 1.0){
 shared_ptr<material> sphere_material;

 if(choose_mat < 0.8){
 //漫反射
 auto albedo = color::random() * color::random();
 sphere_material = make_shared<lambertian>(albedo);
 world.add(make_shared<sphere>(center,0.2,sphere_material));
 }else if(choose_mat < 0.95) {
 //金属
 auto albedo = color::random(0.5,1);
 auto fuzz = random_double(0,0.5);
 sphere_material = make_shared<metal>(albedo,fuzz);
 world.add(make_shared<sphere>(center,0.2,sphere_material));
 }else{
 //玻璃
 sphere_material = make_shared<dielectric>(1.5);
 world.add(make_shared<sphere>(center,0.2,sphere_material));
 }
 }
 }
 }

 auto material1 = make_shared<dielectric>(1.5);
 world.add(make_shared<sphere>(point3(0,1,0),1.0,material1));

 auto material2 = make_shared<lambertian>(color(0.4, 0.2, 0.1));
 world.add(make_shared<sphere>(point3(-4, 1, 0), 1.0, material2));

 auto material3 = make_shared<metal>(color(0.7, 0.6, 0.5), 0.0);
 world.add(make_shared<sphere>(point3(4, 1, 0), 1.0, material3));

 camera cam;

 cam.aspect_ratio = 16.0 / 9.0;
 cam.image_width = 800;
 cam.samples_per_pixel = 100;
 cam.max_depth = 50;


 cam.vfov = 20;
 cam.lookfrom = point3(13,2,3);
 cam.lookat = point3(0,0,0);
 cam.vup = vec3(0,1,0);

 cam.defocus_angle = 0.6;
 cam.focus_dist = 10.0;

 cam.render(world);
}

初始图形学(13)

Fri, 24 Oct 2025 20:23:06 +0800

自从上个学期之后，就怎么接触过图形学了。但是仔细感受下来，图形学是最让人有收获感的方向。它通过模拟真实的物理规则，通过计算模拟出真实的模拟场景，十分有趣，就是给人一种融汇贯通的感觉，学到的知识能结合在一起，我感觉这才是最有意义的地方。

初始图形学(14)

Tue, 02 Dec 2025 15:27:57 +0800

书接上回，上一次实现了物体运动下的图形学渲染。实现了动态模糊的构建。

包围体积层级

现在随着我们场景的复杂化，和对图片质量的提升，有时候渲染一张照片都需要十几分钟。为了让代码运行的更快，我们需要引入一个新的结构 包围体积层级BVH，以优化程序渲染的性能。

初始图形学(15)

Thu, 04 Dec 2025 23:09:01 +0800

上一章中完成了对图形渲染的饿BVH加速，现在我们要尝试将图片纹理映射到物体中。

纹理映射

图形学中的纹理映射是将材质效果应用于场景中的物理过程。其中"纹理"指的是效果（这个效果可以是材质属性，或是部分存在与否）本身，而映射则是将效果映射到物体的表面上。

小试Lua

Fri, 03 Jul 2026 12:53:21 +0000

Lua 是一门小型的脚本语言。我学习他的最初目的是因为他简单的设计理念，简单的语法和实现，学习成本很低（但是要学好还是难的），以及由于其实现简单，被广泛运用在嵌入式领域中，我觉的很有意思。后面在慢慢学习的过程中，我发现Lua也是学习编译原理、虚拟机和脚本引擎的一个很好的开始。恰巧我对这些都很感兴趣。所以暑假我想好好研究一下这个语言，看看能不能把他融入进我现在技术路线里面。

编写一个HTTP服务器

Thu, 11 Jun 2026 09:55:58 +0000

这个学期在学计算机网络，我终于开悟了。我之前一直是网络方面的白痴，这次的话就学习一个小的C语言网络编程的项目——“tinyhttpd”，主要是别记录边进行重写吧。加深一下对http协议的印象，顺便学习一下网络编程相关的知识。

从C升级到CPP

Wed, 27 May 2026 10:19:10 +0800

我平时日常是使用C和Python进行开发，但是随着用的时间越来越长。我感觉这两个语言的局限性还是比较明显的，无法满足我的日常开发需求。现在的话我需要一门日常的开发语言。C的话过于底层，我平时用来学习做实验比较多，但是开发一些大型的项目比较麻烦。Python的话很好用，但是不方便打包，导致很多场景下用起来比较麻烦。Java太重了，各种环境配置和规范写起来很麻烦。Rust和Go的话感觉太新了，我最近研究他们的语法感觉还是很不习惯。

深入理解Ptmalloc2(上)

Tue, 14 Apr 2026 15:03:53 +0800

其实一点也不深入，最近在学堆利用。但是很吃力，看了一天的内存分配的过程，还有malloc的实现，还有各种乱七八糟的小知识点后，我打算自己整理一遍ptmalloc2的机制。

记录一次wsl的配置

Sat, 28 Mar 2026 13:50:13 +0800

之前是在wsl中用的Debian的发行版，shell用的是fish，一开始觉得很好用，后面越用感觉坑越多。比如fish和bash在语法上的不兼容，还有就是fish的一些报错感觉怪怪的。最重要就是这两个shell在环境上会有冲突，大多数程序会默认将自己的系统路径放在.bashrc中，但是这样fish就会读取不到，总之就是很麻烦，fish的语法高亮和智能补全都很好用。但我还是选择回到最普通的bash好了。顺便重装以下整理我的系统环境。

Python字节码解释器基本原理

Tue, 09 Dec 2025 19:43:00 +0800

找到一个比较好的项目[Byterun](A Python Interpreter Written in Python by qingyunha)，这里进行一下复现。

Byterun

Byterun 是一个基于Python实现的Python字节码解释器，简化了Cpython的实现，展示了Python解释器在底层上的实现原理，以及相关的组织过程。

DWADRF信息解析

Mon, 24 Nov 2025 10:26:27 +0800

上个学期也尝试了解过这些，但是那个时候还没有接触编译链接，对DWARF信息的理解不够深刻。最近有计划了解一下调试器的原理，所以重新捡起来好好学一遍。

背景驱动的双态图像显现

Thu, 14 Aug 2025 09:46:14 +0800

在网上冲浪的时候我们经常会看到一些点开与不点开会呈现不同结果的图片，我们称这种图片为"幻影坦克图"。因为它利用到了光学欺骗的原理，与红警中的幻影坦克相似，故得其名。今天，尝试了解下背后的原理，并自己动手实现一下这个功能。

mov指令的图灵完备性

Sun, 06 Jul 2025 13:13:18 +0800

文章原文：mov is Turing-complete ——by Stephen Dolan，Computer Laboratory, University of Cambridge

不使用特殊的寻址模式，代码自修改，和运行时生成代码。用mov实现图灵完备的模拟器

QOI编码解析

Fri, 06 Jun 2025 21:51:31 +0800

我突然理解什么是解释器了，解释器的话全称应该理解为字节码解释器。本质上是对特定的数据赋予一定的规则下的意义，然后用同样的规则可以去解读同一个数据，这个实际上就是信息论。我们的解释器，机器码之类的也是这样，数据本没有意义，但是特定的规则赋予了其意义即信息。

动手实现内存分配

Wed, 07 May 2025 13:34:56 +0800

学习虚拟内存，对于其中的malloc的实现有一定兴趣，所以深入研究一下

研究

首先我们知道malloc的函数原型：

void * malloc(size_t size);

我们可以用它申请一个指定大小的内存空间，其中size是我们申请的空间，于是我们我们可以简单的实现这个功能：

简易的垃圾回收机制

Wed, 09 Apr 2025 19:39:43 +0800

大佬的技术博客，拜读了一下，理解的七七八八，做一个记录和研究吧。

文章地址： Baby’s First Garbage Collector – journal.stuffwithstuff.com

简易的垃圾回收机制

在计算机运行的过程中，会不断的分配和释放内存。尤其是在一些低级的语言中，内存的分配和释放都需要程序员手动分配。如果不对内存加以分配和管理，就会导致系统资源耗尽，从而发生内存泄露。或者如果错误的释放了正在使用的内存空间，那么又会导致系统崩溃。所以一个合理的垃圾回收机制，可以自动识别并回收不再使用的内存，减轻程序员的负担。

虚拟机在C的实现

Sun, 16 Mar 2025 13:44:37 +0800

项目地址 https://www.jmeiners.com/lc3-vm/#running-the-vm

什么是虚拟机

虚拟机是一种像计算机一样的程序。它模拟CPU和一些其他的硬件组件的功能，使其能够实现算术运算，内存读写，还有与I/O设备的交互。最重要的是，你可以理解你为其定义的机器语言，然后用它来编程。

动手写shell

Fri, 14 Mar 2025 14:19:22 +0800

最近一直在学习，但是却忽略了最基本的需求——想要有所反馈，所以的话找了几个项目来做一做，这里的话我挑选的是一个用C语言实现shell的项目，用的是Linux编程，刚好我还没有试过在WSL上的编程开发，所以试一试呀，顺便把这个英语博客翻译一遍，锻炼下水平。

CE修改器入门教程

Sat, 08 Feb 2025 14:29:48 +0800

久仰CE修改器大名，今天来学习一下CE的基础使用（官方教程）

我看网上有很多图文教程，在此就尽量不配图。主要记录学习过程中的感受心得为主

打开进程

这一步没啥难度，不做说明

栈的工作原理及栈溢出的使用

Sat, 08 Feb 2025 10:46:10 +0800

书接上回这一篇主要讲一下，当一个C语言函数在执行时，操作系统是如何调度内存将数据存放并完成相关函数操作的

C语言内存分布

当一个C语言程序被编译成可执行文件执行时，它在内存中的存储如右图所示。这是一个内存空间，地址由底部逐渐升高：

My_First_Blog

Thu, 16 Jan 2025 20:31:33 +0800

这是我的第一篇博客，这个博客搭建花了很多时间，遇到了很多问题，在这里分享一下

环境配置

首先是环境的配置

你需要安装 node.js 作为包管理器进行 Hexo 网站的搭建

其次你需要将 git 与你的 github 账号建立SSH通道