的联盟

Question

我正在为自定义编程语言（连接，软键入）编写解释器，为此我有一个中心数据类型Token。令牌可以是许多不同类型中的一种，可以是标量的也可以是矢量的。为了最大限度地减少内存量，我首先使用union，但之后我只能在联合中使用普通的数据结构，因此我使用了struct所有字段（long asInteger; }，boost::shared_ptr<std::string> asString，...）。从记忆消费的角度来看，这当然是一个坏主意，但它完成了工作。

由于Token数据类型的长度几乎为100个字节（例如，使得1,000,000个整数的数组几乎为100兆字节），原始配方显示大量不足。今天我修改了实现，用复制语义动态分配每个元素所需的内存，这样如果我可以在类中使用它，我就会得到类似于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;

现在上面的代码正常工作，但速度非常慢（比之前使用union的实现慢200％）。分析器显示几乎一半的执行时间花费在new和free()上。我已尝试在char data[50]上使用放置新语法，以便在适用时在堆栈上分配Token对象的空间，并且在所有情况下仅分配一次，并且速度提高很多但仍然没有原始速度快（大约慢20％）。

我的问题是：我如何才能更频繁地分配小物件？

如果这通常以完全不同的方式完成，请告诉我该怎么做。我通常需要一个健壮且快速但不“智能”（自动转换......）的变体类型，因为我有自己的框架。一般来说，我希望最小化内存分配成本，同时最小化所需的内存。

谢谢你的帮助！

Answer 1

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

的联盟

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

升压::变体

如果你有权访问boost库那么我肯定会使用它。我认为它不会像工会一样节省内存，但它比保存所有值节省了更多。这也允许非泛型类型。此外，您不必跟踪正在使用的类型。您需要记录的就是您编写类型的顺序。

我会说 Boost :: variant ，但可以使用union。

变体类型令牌的内存分配

1 个答案:

的联盟

升压::变体