变体类型令牌的内存分配

Question

我正在为自定义编程语言(连接，软类型(制作解释器，为此我有一个中央数据类型Token。令牌可以是许多不同类型的一种，可以是标量令牌，也可以是矢量令牌。为了最小化内存量，我首先使用了一个union，但后来我只能在联合中使用普通的数据结构，所以我求助于包含所有字段(long asInteger;、boost::shared_ptr<std::string> asString、...(的struct。从内存消耗的角度来看，这当然是一个坏主意，但它完成了工作。

由于Token数据类型的长度几乎为 100 字节(例如，使 1,000,000 个整数的数组接近 100 MB(，因此原始公式显示出严重不足。今天，我改进了实现，以使用复制语义动态分配每个元素所需的内存，以便我可以将其与类一起使用，则我得到了类似于union的东西。

这是新的类定义：

class Token {
protected:
    TokenType tokenType_;
    template<class T>
    inline void copyToken(void * src, void * dst)
    {
      *static_cast<T*>(dst) = 
          *static_cast<T*>(src);
    };
    template<class T>
    inline void deleteValue()
    {
      delete static_cast<T*>(data);
    };
    void deleteData()
    {
        switch (tokenType_)
        {
            case T_INTEGER:   deleteValue<long>(); break; 
            case T_BOOL:      deleteValue<bool>(); break; 
            case T_FLOAT:     deleteValue<double>(); break;
            case T_STRING:    deleteValue<boost::shared_ptr<std::string>>(); break;  
            case T_ARRAY:     deleteValue<boost::shared_ptr<std::vector<Token>>>(); break;
            case T_HANDLE:    deleteValue<HandleData>(); break;
            default: ;
        }
    }
    void allocate(const TokenType tokenType)
    {       
        switch (tokenType)
        {
            case T_INTEGER:   data = new long; break; 
            case T_BOOL:      data = new bool;  break; 
            case T_FLOAT:     data = new double; break;
            case T_STRING:    data = new boost::shared_ptr<std::string>; break;  
            case T_ARRAY:     data = new boost::shared_ptr<std::vector<Token>>; break;
            case T_HANDLE:    data = new HandleData; break;
            default: data = NULL;
        }     
    };
    void * data;
public:
    void set_type(const TokenType tokenType)
    {
        deleteData();
        tokenType_ = tokenType;
        allocate(tokenType);
    };
    Token() : tokenType_ (T_EMPTY) { data = NULL; }; 
    Token(const TokenType tokenType) : tokenType_ (tokenType)  
    {
        allocate(tokenType);
    };
    Token(const Token& old_token)  
    {
        tokenType_ = old_token.tokenType_;
        allocate(old_token.tokenType_);
        switch (old_token.tokenType_)
        {
            case T_INTEGER:   copyToken<long>(old_token.data, data); break; 
            case T_BOOL:      copyToken<bool>(old_token.data, data); break; 
            case T_FLOAT:     copyToken<double>(old_token.data, data); break;
            case T_STRING:    copyToken<boost::shared_ptr<std::string>>(old_token.data, data); break; 
            case T_ARRAY:     copyToken<boost::shared_ptr<std::vector<Token>>>(old_token.data, data); break;
            case T_HANDLE:    copyToken<HandleData>(old_token.data, data); break;
            default: ;
        }       
    };
    template<class T>
    T& retreive()
    {
        return *static_cast<T*>(data);
    };
    template<class T>
    const T& retreive() const
    {
        return *static_cast<T*>(data);
    };
    void operator=(const Token &rhs) 
    {
        fileName = rhs.fileName;
        lineNum  = rhs.lineNum;
        set_type(rhs.tokenType_);
        switch (rhs.tokenType_)
        {
            case T_INTEGER:   copyToken<long>(rhs.data, data); break; 
            case T_BOOL:      copyToken<bool>(rhs.data, data); break; 
            case T_FLOAT:     copyToken<double>(rhs.data, data); break;
            case T_STRING:    copyToken<boost::shared_ptr<std::string>>(rhs.data, data); break; 
            case T_ARRAY:     copyToken<boost::shared_ptr<std::vector<Token>>>(rhs.data, data); break;
            case T_HANDLE:    copyToken<HandleData>(rhs.data, data); break;
            default: ;
        }       
    };
    ~Token()
    {
       deleteData();
    };
};

然后我会创建一个令牌

Token newToken(T_INTEGER);
newToken.retreive<long>() = 42;

现在上面的代码可以工作了，但非常慢(比以前的联合实现慢 200%(。探查器显示，几乎一半的执行时间都花在了new和free()上。我尝试在char data[50]上使用放置新语法，以便在适用时在堆栈上分配Token对象的空间，并且在所有情况下仅分配一次，这大大加快了速度，但仍然不如原始速度快(大约慢 20%(。

我的问题是：我该如何使这种频繁的小对象的分配更精简、更快捷？

如果这通常以完全不同的方式完成，请告诉我如何做。我通常需要一个强大而快速但不"智能"(自动转换等(的变体类型，因为我有自己的框架。通常，我希望最小化内存分配成本，同时最小化所需的内存。

谢谢你的帮助！

Answer 1

我知道这已经有好几年的历史了，似乎你找到了你的答案，但你从未发布过它，所以如果有人偶然发现这篇文章，我会解释一些解决方案(就像我一样(。

联盟

是的，可以使用您最终避免的相同数据结构。这将大大减少数据量。假设你有这四种类型：bool、int、float和double。联合的大小将永远是最大的，这不是最好的，但它比所有元素的大小都要好。现在，你说">...我只能在工会中使用普通的数据结构......"这是真的，但它可以指向非泛型类型的指针。这可以解决大部分内存问题，但如果使用指针，则必须使用new和delete，因此您仍然会因此而运行得更慢。使用联合的另一个缺点是您必须跟踪正在使用的类型。

提升：：变体

如果你可以访问提升库，那么我肯定会选择这个。我不认为它像联合一样节省那么多内存，但它比保存所有值节省的要多得多。这也允许非泛型类型。此外，您不必跟踪正在使用哪种类型。您所需要跟踪的只是您编写类型的顺序。

我会说使用Boost：：变体，但可以使用工会。