C++口译员概念问题

Question

我已经用 C++ 为我创建的语言构建了一个解释器。

设计中的一个主要问题是我的语言有两种不同的类型：数字和字符串。所以我必须传递一个结构，例如：

class myInterpreterValue
{
 myInterpreterType type;
 int intValue;
 string strValue;
}

在我的语言中的倒计时循环期间，此类的对象每秒传递大约百万次。

分析指出：85% 的性能被字符串模板的分配函数消耗掉了。

这对我来说非常清楚：我的解释器设计很糟糕，并且没有充分使用指针。然而，我没有选择：在大多数情况下我不能使用指针，因为我只需要复制。

如何对此采取措施？像这样的课程是更好的主意吗？

vector<string> strTable;
vector<int> intTable;
class myInterpreterValue
{
 myInterpreterType type;
 int locationInTable;
}

因此该类只知道它代表什么类型以及在表中的位置

但这又存在缺点： 我必须向 string/int 向量表添加临时值，然后再次删除它们，这会再次消耗大量性能。

• 求助，Python 或 Ruby 等语言的解释器是如何做到这一点的？他们以某种方式需要一个结构来表示语言中的值，例如可以是 int 或 string 的值。

Answer 1

我怀疑许多值不是字符串。因此，您可以做的第一件事就是删除 string 对象（如果您不需要它）。将其放入工会。另一件事是，可能许多字符串都很小，因此如果将小字符串保存在对象本身中，则可以摆脱堆分配。 LLVM 有一个 SmallString 模板。然后你可以使用字符串驻留，正如另一个答案所说。 LLVM 有 StringPool 类：调用 intern ("foo") 并获取一个智能指针，该指针引用其他 myInterpreterValue 对象也可能使用的共享字符串。

联合可以这样写

class myInterpreterValue {
 boost::variant<int, string> value;
};

boost::variant 为您做类型标记。如果你没有 boost，你可以这样实现。对齐方式在 C++ 中还无法移植，因此我们将一些可能需要较大对齐方式的类型推入存储联合中。

class myInterpreterValue {
 union Storage {
   // for getting alignment
   long double ld_;
   long long ll_;

   // for getting size
   int i1;
   char s1[sizeof(string)];

   // for access
   char c;
 };
 enum type { IntValue, StringValue } m_type;

 Storage m_store;
 int *getIntP() { return reinterpret_cast<int*>(&m_store.c); }
 string *getStringP() { return reinterpret_cast<string*>(&m_store.c); }


public:
  myInterpreterValue(string const& str) {
    m_type = StringValue;
    new (static_cast<void*>(&m_store.c)) string(str);
  }

  myInterpreterValue(int i) {
    m_type = IntValue;
    new (static_cast<void*>(&m_store.c)) int(i);
  }
  ~myInterpreterValue() {
    if(m_type == StringValue) {
      getStringP()->~string(); // call destructor
    }
  }
  string &asString() { return *getStringP(); }
  int &asInt() { return *getIntP(); }
};

你明白了。

Answer 2

我认为某些动态语言在运行时通过哈希查找缓存所有等效的字符串，并且仅存储指针。因此，在字符串保持不变的循环的每次迭代中，只会有一个指针分配或最多一个字符串哈希函数。我知道一些语言（Smalltalk，我想？）不仅可以使用字符串，还可以使用小数字来实现此目的。请参阅享元模式。

IANAE 关于这一点。如果这没有帮助，您应该提供循环代码并引导我们了解它是如何解释的。

Answer 3

在 Python 和 Ruby 中，整数都是对象。所以这不是“值”是整数还是字符串的问题，它可以是任何东西。此外，这两种语言中的所有内容都会被垃圾收集。不需要复制对象，指针可以在内部使用，只要它们安全地存储在垃圾收集器能够看到它们的地方即可。

因此，解决您的问题的一种方法是：

class myInterpreterValue {
    virtual ~myInterpreterValue() {}
    // example of a possible member function
    virtual string toString() const = 0;
};

class myInterpreterStringValue : public myInterpreterValue {
    string value;
    virtual string toString() const { return value; }
};

class myInterpreterIntValue : public myInterpreterValue {
    int value;
    virtual string toString() const {
        char buf[12]; // yeah, int might be more than 32 bits. Whatever.
        sprintf(buf, "%d", value);
        return buf;
    }
};

然后使用虚拟调用和 dynamic_cast 来打开或检查类型，而不是与 myInterpreterType 的值进行比较。

此时通常要做的事情是担心虚拟函数调用和动态转换可能会很慢。 Ruby 和 Python 到处都使用虚函数调用。尽管不是 C++ 虚拟调用：对于这两种语言，它们的“标准”实现都是用 C 语言实现的，具有自定义的多态性机制。但原则上没有理由假设“虚拟”意味着“性能超出预期”。

也就是说，我希望它们可能都对整数的某些用途进行了一些巧妙的优化，包括作为循环计数器。但是，如果您当前发现大部分时间都花在复制空字符串上，那么相比之下，虚拟函数调用几乎是瞬时的。

真正担心的是您将如何进行资源管理 - 取决于您对解释语言的计划，垃圾收集可能比您想要的更麻烦。

Answer 4

解决这个问题的最简单方法是使其成为指向字符串的指针，并且仅在创建字符串值时才分配它。您还可以使用 union 来节省内存。

class myInterpreterValue
{
 myInterpreterType type;
 union {
  int asInt;
  string* asString;
 } value;
}