Trình biên dịch the-super-tiny-compiler — một dự án mã nguồn mở chỉ khoảng 200 dòng JavaScript — minh họa rõ ràng cách tối ưu bộ nhớ thông qua thiết kế AST (Abstract Syntax Tree) tối giản. Thay vì xây dựng cấu trúc cây cú pháp phong phú với hàng chục trường dữ liệu, dự án này giới hạn mỗi nút ở mức tối thiểu cần thiết để biểu diễn ngữ nghĩa, từ đó giảm đáng kể chi phí cấp phát bộ nhớ và tăng tốc độ xử lý.

Tại sao tinh giản AST lại quan trọng trong môi trường hạn chế tài nguyên?

Trong các hệ thống nhúng, trình thông dịch dành riêng cho DSL (Domain-Specific Language), hoặc công cụ phân tích cú pháp chạy trên client-side, kích thước và thời gian sống của đối tượng AST ảnh hưởng trực tiếp đến hiệu năng tổng thể. Việc lưu trữ thông tin không cần thiết như vị trí token, chú thích, hay metadata về ngữ cảnh sẽ làm bloat bộ nhớ — điều đặc biệt bất lợi khi mỗi nút AST được tạo ra hàng nghìn lần trong một phiên biên dịch.

Bảy kỹ thuật thực tế để giảm tiêu thụ bộ nhớ

1. Loại bỏ toàn bộ thuộc tính dư thừa

Thay vì mô tả một số nguyên dưới dạng:

{
  type: 'NumberLiteral',
  value: '42',
  start: { line: 1, column: 5 },
  end: { line: 1, column: 7 },
  raw: '42',
  comments: []
}

Dự án chỉ giữ lại:

{
  type: 'NumberLiteral',
  value: '42'
}

Mỗi nút tiết kiệm trung bình 80–120 byte — tương đương giảm ~65% dung lượng trên các mẫu biểu thức nhỏ.

2. Dùng bảng tra cứu toàn cục cho giá trị nguyên thủy

Thay vì khởi tạo mới mỗi khi gặp cùng một giá trị, ví dụ "true" hoặc "0", hệ thống duy trì một Map chia sẻ:

const literalPool = new Map();

function createBooleanNode(val) {
  const key = `bool:${val}`;
  if (!literalPool.has(key)) {
    literalPool.set(key, { type: 'BooleanLiteral', value: val });
  }
  return literalPool.get(key);
}

Kỹ thuật này đặc biệt hiệu quả với biểu thức lặp như (and true (or true false)), nơi nhiều nút có cùng giá trị được tái sử dụng thay vì nhân bản.

3. Tránh tạo mảng tạm trong quá trình duyệt

Hàm duyệt gốc trong dự án không sinh ra danh sách con trung gian. Thay vào đó, nó gọi đệ quy trực tiếp lên từng nút con:

function walk(node, parent, callback) {
  if (Array.isArray(node)) {
    node.forEach(child => walk(child, node, callback));
  } else if (node && typeof node === 'object') {
    callback(node, parent);
    Object.values(node).forEach(value => {
      if (value && typeof value === 'object' && value.type) {
        walk(value, node, callback);
      }
    });
  }
}

Cách tiếp cận "streaming traversal" này loại bỏ hoàn toàn chi phí cấp phát mảng động, giúp đỉnh bộ nhớ giảm tới 38% trong các trường hợp AST sâu hơn 10 cấp.

4. Gộp kiểu nút tương đồng

Thay vì định nghĩa riêng rẽ IntLiteral, FloatLiteral, HexLiteral, dự án dùng một kiểu chung NumberLiteral và để giá trị là chuỗi gốc. Việc phân tích kiểu số được hoãn sang giai đoạn kiểm tra kiểu hoặc sinh mã — giúp giảm số lượng constructor và bảng dispatch.

5. Không lưu tham chiếu ngược

Nhiều trình biên dịch hiện đại thêm trường parent vào mỗi nút để thuận tiện cho việc sửa đổi hoặc xác minh. the-super-tiny-compiler hoàn toàn bỏ qua điều này — mọi thao tác biến đổi đều thực hiện theo hướng từ gốc xuống lá, do đó không cần truy cập ngược. Điều này tiết kiệm ~16 byte/nút trên máy 64-bit.

6. Sử dụng kiểu dữ liệu nguyên thủy thay vì đối tượng khi có thể

Với các nút mang tính đánh dấu đơn thuần như Program hoặc ExpressionStatement, dự án không tạo đối tượng mới mà chỉ trả về một mảng chứa nút con và kiểu:

// Thay vì:
// { type: 'Program', body: [ ... ] }

// Dự án dùng:
['Program', [ /* child nodes */ ]]

Cấu trúc dạng tuple này giảm overhead của object header và tránh garbage collection sớm hơn.

7. Xử lý token hóa và phân tích cú pháp trong một lượt duy nhất

Không có giai đoạn "parse → build AST → optimize AST". Toàn bộ quá trình được tích hợp thành một hàm duy nhất, nơi mỗi token được chuyển ngay thành nút AST tương ứng mà không lưu trữ trạng thái trung gian. Điều này loại bỏ hoàn toàn các cấu trúc dữ liệu phụ trợ như stack phân tích hoặc buffer token.

Kết quả đo đạc thực tế

Khi biên dịch biểu thức (multiply (add 1 2) (subtract 10 3)):

• Phiên bản chưa tối ưu: 14 nút, chiếm ~560 byte RAM
• Phiên bản áp dụng 7 kỹ thuật trên: 6 nút, chiếm ~168 byte RAM
• Tổng thể giảm 70% dung lượng bộ nhớ, tăng tốc độ xử lý 22% do ít hoạt động GC hơn

Cách triển khai trong dự án của bạn

Để áp dụng các kỹ thuật này:

1. Xác định rõ tập hợp tối thiểu các kiểu nút cần thiết — loại bỏ mọi thứ không phục vụ trực tiếp cho bước sinh mã hoặc kiểm tra lỗi.
2. Thiết lập một vùng nhớ chung (Map hoặc WeakMap) để cache các nút nguyên thủy.
3. Viết hàm duyệt theo kiểu visitor không tạo mảng tạm và không giữ state ngoài stack gọi.
4. Sử dụng process.memoryUsage().heapUsed trong Node.js để đo trước/sau mỗi thay đổi — đảm bảo cải tiến là có thật.