web-dev-qa-db-ja.com

デバッグアサーションに失敗しました…_BLOCK_TYPE_IS_VALID（pHead-> nBlockUse）

修正しようとしている非常に悪いメモリリークがありますが、どういうわけか、このアサーションをトリガーせずにオブジェクトを削除することはできません。

Googleで解決策を検索し、このエラーに関するstackoverflowの質問を読みましたが、それでも答えを見つけることができませんでした。

私の調査によると、このエラーが発生する考えられる理由：
1。複数のオブジェクトを削除する
2。シャドウコピー
3。外部dllからロードされるオブジェクトの作成と削除
4。ポインタを保存せずにオブジェクトを作成する

だが：
1。コードを確認しましたが、二重削除が見つかりませんでした
2。コピーコンストラクターを使用してオブジェクトをコピーします
3。エラー関連クラスは、（MS Visual Studioを使用して）別のlibにビルドされますが、dllにはビルドされません。そして、このエラーに関連するすべてのクラスは同じライブラリにあります。
4。コードを確認しましたが、問題ないようです

誰かが以下のコードの間違いを見つけることができれば素晴らしいと思います。問題の解決策を示すすべてのヒントに感謝します。

編集：
MessageSystemのsendThreadMainで同じ削除の問題について言及するのを忘れました（以下のコードを参照）。そこでメッセージを削除すると、コードのどこかで予期しないエラーが発生します。間違ったデータ転送かもしれません...しかし、私は本当に知りません。
このコードはWindowsとLinuxで実行されます！

コードのエラー関連部分は次のとおりです。

メッセージ

class Message 
{
public:
    Message (char type, unsigned char id, unsigned short size) 
    {
        mType = type;
        mId = id;
        mSize= size;
    }

    Message(const Message &o)
    {
        mType = o.mType;
        mId = o.mId;
        mSize = o.mSize;
    }

    char getType() const {return mType;};
    unsigned char getId() const {return mId;};
    unsigned short getSize() const {return mSize;};

protected:
    char mType;
    unsigned char mId;
    unsigned short mSize;
};


class JoinMessage : public Message
{
public:
    JoinMessage () : Message ('j', 0, sizeof (JoinMessage))
    {
        team = TEAM_SPECTATOR;
    }
    JoinMessage (unsigned char id) : Message ('j', id, sizeof (JoinMessage)){}
    JoinMessage (const JoinMessage &o) : Message (o)
    {
        team = o.team;
        setName(o.getName());
    }


    void setName(std::string newName)
    {
        if (newName.length() > MAX_PLAYER_NAME_LENGHT)
            newName = newName.substr(0, MAX_PLAYER_NAME_LENGHT);

        memset(name, 0, MAX_PLAYER_NAME_LENGHT);
        for(unsigned int i = 0; i < newName.length(); i++)
            name[i] = newName[i];
    }

    std::string getName() const
    {
        std::string stringToReturn;

        for(unsigned int i = 0; i < MAX_PLAYER_NAME_LENGHT; i++)
        {
            if (name[i])
                stringToReturn.Push_back(name[i]);
            else
                break;
        }

        return stringToReturn;
    }

    TeamIdentifier team;

private:
    unsigned char name[MAX_PLAYER_NAME_LENGHT];
};

// there are a lot other messages

メッセージキュー

MessageQueue::~MessageQueue()
{
    boost::mutex::scoped_lock lock (queueMutex);

    while(messageQueue.size() > 0)
    {
        // the crash is non-reproducible
        // works 90% of the time
        delete messageQueue.front (); // <- Debug Assertion Failed … _BLOCK_TYPE_IS_VALID
        messageQueue.pop_front();
    }

}

void MessageQueue::enqueMessage (Message* message)
{
    {
        boost::mutex::scoped_lock lock (queueMutex);
        messageQueue.Push_back(message);
    }
}

Message* MessageQueue::dequeMessage ()
{
    boost::mutex::scoped_lock lock (queueMutex);
    if (messageQueue.size() == 0) 
        return nullptr;

    Message* message = messageQueue.front ();
    messageQueue.pop_front();

    return message;
}

MessageSystem

template <class MessageType>
void broadcast (MessageType &message)
{
    MessageType *internMessage = new MessageType(message);

    boost::mutex::scoped_lock lock (mRecipientMapMutex);
    std::map <boost::asio::ip::udp::endpoint, MessageQueue *>::iterator it;

    for (it = mRecipientMap.begin ();
        it != mRecipientMap.end ();
        it++)
    {
        it->second->enqueMessage(internMessage);

    }
}


template <class MessageType>
void post (MessageType &message, boost::asio::ip::udp::endpoint &recipient)
{
    MessageType *internMessage = new MessageType(message);

    std::map <boost::asio::ip::udp::endpoint, MessageQueue* >::iterator it;
    MessageQueue *messageQueue = NULL;
    {
        boost::mutex::scoped_lock lock (mRecipientMapMutex);
        it = mRecipientMap.find (recipient);
        if (it != mRecipientMap.end())
            messageQueue = it->second;

        if(messageQueue)
            messageQueue->enqueMessage (internMessage);
    }

}


void MessageSystem::sendThreadMain ()
{
    // copy endpoints to vecotr so it can be
    // deleted from map while iterating
    std::vector<udp::endpoint> endpoints;
    {
        boost::mutex::scoped_lock lock (mRecipientMapMutex);
        std::map <udp::endpoint, MessageQueue *>::iterator mapIt = mRecipientMap.begin ();
        while (mapIt != mRecipientMap.end())
        {
            endpoints.Push_back(mapIt->first);
            mapIt++;
        }
    }

    std::vector<udp::endpoint>::iterator endpointIt = endpoints.begin();
        while (endpointIt != endpoints.end())
        {
            char sendBuffer[PACKET_SIZE];
            int sendBufferPosition = 0;
            {
                boost::mutex::scoped_lock lock (mRecipientMapMutex);

                MessageQueue *messageQueue = mRecipientMap[*endpointIt];
                if (messageQueue == nullptr)
                {
                    mRecipientMap.erase(*endpointIt);
                    endpointIt++;
                    continue;
                }

                while (Message *message = messageQueue->dequeMessage ())
                {
                    if (sendBufferPosition + message->getSize() > PACKET_SIZE) 
                    {
                        // put message back and send it later
                        messageQueue->enqueMessage (message);
                        break;
                    }

                    // copy message into buffer
                    std::memcpy (
                        &sendBuffer [sendBufferPosition], message, message->getSize());

                    sendBufferPosition += message->getSize();
                    // deleting this message causes a crash if 2 or more
                    // recipients are registered within MessageSystem
                    //delete message; <- RANDOM CRASH elsewhere in the program
                }
            }
    .... // more code down here that seems not related to the error
c++memory-leaksassert
16
cwin

今日、私は自分でそれを理解しました。それは質問で言及された4つの可能性の＃1でした。

  1. オブジェクトを複数回削除する（まったく同じオブジェクトへの複数のポインターを保存することにより）

これがMessageQueueの私の解決策です：

template <class MessageType>
void broadcast (MessageType &message)
{
    // I was creating 1 new Message right here but I need 1 new Message
    // in EVERY MessageQueue so i moved the next line ...
    // MessageType *internMessage = new MessageType(message);

    boost::mutex::scoped_lock lock (mRecipientMapMutex);
    std::map <boost::asio::ip::udp::endpoint, MessageQueue *>::iterator it;

    for (it = mRecipientMap.begin ();
        it != mRecipientMap.end ();
        it++)
    {
        // ... down here. Now every queue contains its own copy of the Message
        MessageType *internMessage = new MessageType(message);
        it->second->enqueMessage(internMessage);
    }
}
3
cwin

さて、私は同様の問題に直面しました、次のコード

Message* message = messageQueue.front ();
messageQueue.pop_front();

return message;

私と一緒にエラーを発生させたコードは次のとおりです。

Point *p = q.LookFor(&q, &pts[5], &Dist);
cout ...
delete p;

関数は実行時に作成したポインタを削除するようですので、「再度」削除することはできません。

だから私はそれを置き換えました

Point p = *(q.LookFor(&q, &pts[5], &Dist));

そしてそれはなくなった。

1
Ahmed U3

それは間違った順序の単純な問題かもしれません。あなたがやっている：

while(messageQueue.size() > 0)
{
    delete messageQueue.front();
    messageQueue.pop_front();
}

たぶん、メッセージをポップする前ではなく、ポップした後に削除すると、トリックが実行されます。

while(messageQueue.size() > 0)
{
    Message* pFront = messageQueue.front();
    messageQueue.pop_front();
    delete pFront;
}

とにかく、pFrontが指すオブジェクトを削除しても、ポインタを格納するだけのキュー自体には影響しないため、このソリューションにはまったく自信がありません。しかし、あなたは試すことができます。

1
Gorpik