411 lines
13 KiB
C++
411 lines
13 KiB
C++
/*!
|
||
@file src/VM/VM.hpp
|
||
@brief 虚拟机核心执行引擎
|
||
@author PuqiAR (im@puqiar.top)
|
||
@date 2026-02-19
|
||
*/
|
||
|
||
#pragma once
|
||
|
||
#include <Compiler/Compiler.hpp>
|
||
#include <Object/Object.hpp>
|
||
#include <Core/Core.hpp>
|
||
|
||
#include <cassert>
|
||
#include <iostream> // debug
|
||
#include <print>
|
||
|
||
namespace Fig
|
||
{
|
||
struct CallFrame
|
||
{
|
||
FunctionObject *closure; // 动态闭包Context (FastCall时 null)
|
||
Proto *proto; // 当前执行的原型
|
||
Instruction *ip; // 当前指令指针
|
||
Value *registerBase; // 寄存器起点
|
||
|
||
inline Value getConstant(std::uint16_t idx)
|
||
{
|
||
return proto->constants[idx];
|
||
}
|
||
};
|
||
|
||
enum class GCPhase : std::uint8_t
|
||
{
|
||
Idle,
|
||
MarkRoots,
|
||
Marking,
|
||
Sweeping
|
||
};
|
||
|
||
class VM
|
||
{
|
||
private:
|
||
static constexpr unsigned int MAX_REGISTERS = 1024;
|
||
static constexpr unsigned int MAX_GLOBALS = 65536;
|
||
static constexpr unsigned int MAX_RECURSION_DEPTH = 2233;
|
||
|
||
Instruction POISON_MAX_RECURSION_DEPTH_EXCEED_INST;
|
||
|
||
// 一次性分配
|
||
Value registers[MAX_REGISTERS];
|
||
Value globals[MAX_GLOBALS];
|
||
|
||
CallFrame frames[MAX_RECURSION_DEPTH];
|
||
CallFrame *currentFrame;
|
||
CallFrame *frameLimit;
|
||
|
||
Upvalue *openUpvalues = nullptr;
|
||
|
||
// GC
|
||
Object *objects = nullptr; // 链表头
|
||
DynArray<Object *> grayStack;
|
||
|
||
size_t allocatedBytes = 0;
|
||
size_t nextGC = 1024 * 1024; // byte, 1MB初始阈值
|
||
GCPhase gcPhase = GCPhase::Idle;
|
||
|
||
private:
|
||
inline void closeUpvalues(Value *level)
|
||
{
|
||
// 函数销毁时，逃逸即将销毁的变量
|
||
while (openUpvalues && openUpvalues->location >= level)
|
||
{
|
||
Upvalue *upval = openUpvalues;
|
||
upval->closedValue = *upval->location;
|
||
upval->location = &upval->closedValue;
|
||
openUpvalues = upval->next;
|
||
}
|
||
}
|
||
|
||
template <typename T>
|
||
[[nodiscard]] T *allocateObject(ObjectType type, size_t extraBytes)
|
||
{
|
||
|
||
if (allocatedBytes > nextGC) // 超出阈值
|
||
{
|
||
switch (gcPhase)
|
||
{
|
||
case GCPhase::Idle: markRoots(); break;
|
||
case GCPhase::Marking: stepMarking(); break;
|
||
case GCPhase::Sweeping: sweep(); break;
|
||
}
|
||
}
|
||
|
||
size_t totalSize = sizeof(T) + extraBytes;
|
||
|
||
// 物理分配
|
||
T *obj = static_cast<T *>(std::malloc(totalSize));
|
||
if (!obj) [[unlikely]]
|
||
{
|
||
// 分配失败
|
||
CoreIO::GetStdErr() << "Oops! Object allocating failed! Exiting...\n";
|
||
std::exit(1);
|
||
}
|
||
|
||
// 构造 Header
|
||
obj->type = type;
|
||
obj->color = GCColor::Black;
|
||
obj->klass = nullptr;
|
||
obj->next = objects; // 插入全局追踪链表
|
||
objects = obj;
|
||
|
||
allocatedBytes += totalSize;
|
||
return obj;
|
||
}
|
||
|
||
inline void writeBarrier(Object *parent, Value childVal)
|
||
{
|
||
if (!childVal.IsObject())
|
||
return; // 栈对象无需
|
||
|
||
Object *child = childVal.AsObject();
|
||
// 三色不变式, 黑色对象绝对不能指向白色对象
|
||
if (parent->color == GCColor::Black && child->color == GCColor::White)
|
||
{
|
||
child->color = GCColor::Gray;
|
||
grayStack.push_back(child);
|
||
}
|
||
}
|
||
|
||
inline void markValue(Value value)
|
||
{
|
||
if (!value.IsObject())
|
||
return;
|
||
|
||
Object *obj = value.AsObject();
|
||
if (obj && obj->color == GCColor::White)
|
||
{
|
||
obj->color = GCColor::Gray;
|
||
grayStack.push_back(obj);
|
||
}
|
||
}
|
||
|
||
void markRoots()
|
||
{
|
||
// 扫描全局变量
|
||
for (std::uint32_t i = 0; i < MAX_GLOBALS; ++i)
|
||
{
|
||
markValue(globals[i]);
|
||
}
|
||
|
||
// 扫描vm全部栈 [registers[0], currentFrame]
|
||
if (currentFrame && currentFrame->proto)
|
||
{
|
||
Value *stackTop = currentFrame->registerBase + currentFrame->proto->maxRegisters;
|
||
for (Value *slot = registers; slot < stackTop; ++slot)
|
||
{
|
||
markValue(*slot);
|
||
}
|
||
}
|
||
|
||
// 扫描逃逸链表 (Open Upvalues)
|
||
for (Upvalue *uv = openUpvalues; uv != nullptr; uv = uv->next)
|
||
{
|
||
markValue(uv->closedValue);
|
||
}
|
||
|
||
gcPhase = GCPhase::Marking;
|
||
}
|
||
|
||
void stepMarking()
|
||
{
|
||
// 每次步进处理的对象数量
|
||
constexpr int WORK_LIMIT = 64;
|
||
int workCount = 0;
|
||
|
||
while (!grayStack.empty() && workCount++ < WORK_LIMIT)
|
||
{
|
||
Object *obj = grayStack.back();
|
||
grayStack.pop_back();
|
||
|
||
// 标记为黑色：表示该对象及其子引用已处理完毕
|
||
obj->color = GCColor::Black;
|
||
|
||
switch (obj->type)
|
||
{
|
||
case ObjectType::Function: {
|
||
auto *fn = static_cast<FunctionObject *>(obj);
|
||
for (std::uint32_t i = 0; i < fn->upvalueCount; ++i)
|
||
{
|
||
if (fn->upvalues[i])
|
||
markValue(*(fn->upvalues[i]->location));
|
||
}
|
||
break;
|
||
}
|
||
case ObjectType::Instance: {
|
||
auto *inst = static_cast<InstanceObject *>(obj);
|
||
if (inst->klass)
|
||
markValue(Value::FromObject(inst->klass));
|
||
// 扫描所有实例字段
|
||
std::uint8_t fieldCount = inst->klass ? inst->klass->fieldCount : 0;
|
||
for (std::uint8_t i = 0; i < fieldCount; ++i)
|
||
{
|
||
markValue(inst->fields[i]);
|
||
}
|
||
break;
|
||
}
|
||
case ObjectType::Struct: {
|
||
auto *st = static_cast<StructObject *>(obj);
|
||
for (int i = 0; i < GetOperatorsSize(); ++i)
|
||
{
|
||
if (st->operators[i])
|
||
markValue(Value::FromObject(st->operators[i]));
|
||
}
|
||
break;
|
||
}
|
||
case ObjectType::String: break; // 叶子节点
|
||
}
|
||
}
|
||
|
||
if (grayStack.empty())
|
||
gcPhase = GCPhase::Sweeping;
|
||
}
|
||
|
||
void sweep()
|
||
{
|
||
Object **curr = &objects;
|
||
size_t liveBytes = 0;
|
||
|
||
while (*curr != nullptr)
|
||
{
|
||
Object *obj = *curr;
|
||
if (obj->color == GCColor::White)
|
||
{
|
||
*curr = obj->next;
|
||
|
||
// 函数 upvalue需要手动析构
|
||
if (obj->type == ObjectType::Function)
|
||
{
|
||
auto *fn = static_cast<FunctionObject *>(obj);
|
||
fn->name.~String();
|
||
for (std::uint32_t i = 0; i < fn->upvalueCount; ++i)
|
||
{
|
||
Upvalue *uv = fn->upvalues[i];
|
||
if (uv)
|
||
{
|
||
uv->refCount--; // 减引用
|
||
if (uv->refCount == 0)
|
||
{
|
||
// 只有当所有闭包都死后，才 free 这个 Upvalue 结构体
|
||
|
||
std::free(uv);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 持有 C++ 堆资源的成员手动析构!
|
||
else if (obj->type == ObjectType::String)
|
||
{
|
||
static_cast<StringObject *>(obj)->data.~String();
|
||
}
|
||
|
||
std::free(obj);
|
||
}
|
||
else
|
||
{
|
||
// 洗白，仍是一条好汉
|
||
// 以备下次 GC，统计存活大小
|
||
obj->color = GCColor::White;
|
||
|
||
// 计算存活对象的真实物理大小 (Header + 柔性数组/额外数据)
|
||
size_t objectSize = 0;
|
||
switch (obj->type)
|
||
{
|
||
case ObjectType::String: objectSize = sizeof(StringObject); break;
|
||
case ObjectType::Instance:
|
||
objectSize =
|
||
sizeof(InstanceObject)
|
||
+ (obj->klass ? obj->klass->fieldCount * sizeof(Value) : 0);
|
||
break;
|
||
case ObjectType::Function:
|
||
objectSize = sizeof(FunctionObject)
|
||
+ (static_cast<FunctionObject *>(obj)->upvalueCount
|
||
* sizeof(Upvalue *));
|
||
break;
|
||
case ObjectType::Struct: objectSize = sizeof(StructObject); break;
|
||
}
|
||
|
||
liveBytes += objectSize;
|
||
|
||
curr = &obj->next;
|
||
}
|
||
}
|
||
|
||
allocatedBytes = liveBytes;
|
||
// 阈值调整, 当下一次分配超过存活内存的 2 倍时触发 GC
|
||
nextGC = (liveBytes < 512 * 1024) ? 1024 * 1024 : liveBytes * 2;
|
||
|
||
gcPhase = GCPhase::Idle;
|
||
}
|
||
|
||
public:
|
||
VM()
|
||
{
|
||
for (unsigned int i = 0; i < MAX_REGISTERS; ++i)
|
||
{
|
||
registers[i] = Value::GetNullInstance();
|
||
}
|
||
for (unsigned int i = 0; i < MAX_GLOBALS; ++i)
|
||
{
|
||
globals[i] = Value::GetNullInstance();
|
||
}
|
||
|
||
currentFrame = frames;
|
||
frameLimit = frames + MAX_RECURSION_DEPTH - 1;
|
||
|
||
POISON_MAX_RECURSION_DEPTH_EXCEED_INST =
|
||
Op::iAsBx(OpCode::Exit_MaxRecursionDepthExceeded, 0, 0);
|
||
}
|
||
|
||
private:
|
||
[[nodiscard]]
|
||
inline Instruction *pushFrame(Proto *proto, Value *base) // fastcall
|
||
{
|
||
if (++currentFrame >= frameLimit) [[unlikely]] // 达到最大递归层数
|
||
{
|
||
POISON_MAX_RECURSION_DEPTH_EXCEED_INST =
|
||
Op::iAsBx(OpCode::Exit_MaxRecursionDepthExceeded, 0, 0);
|
||
return &POISON_MAX_RECURSION_DEPTH_EXCEED_INST;
|
||
}
|
||
[[likely]]
|
||
*currentFrame = CallFrame{nullptr, proto, proto->code.data(), base};
|
||
return currentFrame->ip;
|
||
}
|
||
|
||
[[nodiscard]]
|
||
inline Instruction *pushFrame(FunctionObject *closure, Value *base) // 普通调用
|
||
{
|
||
if (++currentFrame >= frameLimit) [[unlikely]]
|
||
{
|
||
POISON_MAX_RECURSION_DEPTH_EXCEED_INST =
|
||
Op::iAsBx(OpCode::Exit_MaxRecursionDepthExceeded, 0, 0);
|
||
return &POISON_MAX_RECURSION_DEPTH_EXCEED_INST;
|
||
}
|
||
[[likely]]
|
||
*currentFrame = CallFrame{closure, closure->proto, closure->proto->code.data(), base};
|
||
return currentFrame->ip;
|
||
}
|
||
|
||
inline void popFrame()
|
||
{
|
||
--currentFrame;
|
||
}
|
||
|
||
inline OpCode decodeOpCode(Instruction inst)
|
||
{
|
||
return static_cast<OpCode>(inst & 0xFF);
|
||
}
|
||
inline std::uint8_t decodeA(Instruction inst)
|
||
{
|
||
return (inst >> 8) & 0xFF;
|
||
}
|
||
inline std::uint16_t decodeBx(Instruction inst)
|
||
{
|
||
return (inst >> 16) & 0xFFFF;
|
||
}
|
||
inline std::uint8_t decodeB(Instruction inst)
|
||
{
|
||
return (inst >> 16) & 0xFF;
|
||
}
|
||
inline std::uint8_t decodeC(Instruction inst)
|
||
{
|
||
return (inst >> 24) & 0xFF;
|
||
}
|
||
inline std::int16_t decodeSBx(Instruction inst)
|
||
{
|
||
return static_cast<std::int16_t>(inst >> 16);
|
||
}
|
||
|
||
public:
|
||
// 执行入口：接收 Proto
|
||
Result<Value, Error> Execute(CompiledModule *);
|
||
|
||
void PrintRegisters(std::ostream &ostream = CoreIO::GetStdOut())
|
||
{
|
||
ostream << "=== Registers ===\n";
|
||
for (unsigned int i = 0; i < MAX_REGISTERS; ++i)
|
||
{
|
||
Value &v = registers[i];
|
||
if (!v.IsNull())
|
||
{
|
||
ostream << std::format("[{}] {}\n", i, v.ToString());
|
||
}
|
||
}
|
||
}
|
||
|
||
void PrintGlobals(std::ostream &ostream = CoreIO::GetStdOut())
|
||
{
|
||
ostream << "== Globals ===\n";
|
||
for (unsigned int i = 0; i < MAX_GLOBALS; ++i)
|
||
{
|
||
Value &v = globals[i];
|
||
if (!v.IsNull())
|
||
{
|
||
ostream << std::format("[{}] {}\n", i, v.ToString());
|
||
}
|
||
}
|
||
}
|
||
};
|
||
} // namespace Fig
|