tracy/server/TracyThreadCompress.cpp

#include <limits>

#include "TracyFileRead.hpp"
#include "TracyFileWrite.hpp"
#include "TracyThreadCompress.hpp"

namespace tracy
{

ThreadCompress::ThreadCompress()
    : m_threadLast( std::numeric_limits<uint64_t>::max(), 0 )
{
}

void ThreadCompress::InitZero()
{
    assert( m_threadExpand.empty() );
    m_threadExpand.push_back( 0 );
}

void ThreadCompress::Load( FileRead& f, int fileVer )
{
    assert( m_threadExpand.empty() );
    assert( m_threadMap.empty() );

    uint64_t sz;
    if( fileVer >= FileVersion( 0, 4, 4 ) )
    {
        f.Read( sz );
        if( sz != 0 )
        {
            m_threadExpand.reserve_and_use( sz );
            f.Read( m_threadExpand.data(), sizeof( uint64_t ) * sz );
            m_threadMap.reserve( sz );
            for( size_t i=0; i<sz; i++ )
            {
                m_threadMap.emplace( m_threadExpand[i], i );
            }
        }
    }
    else
    {
        f.Read( sz );
        m_threadExpand.reserve( sz );
        m_threadExpand.push_back( 0 );
    }
}

void ThreadCompress::Save( FileWrite& f ) const
{
    uint64_t sz = m_threadExpand.size();
    f.Write( &sz, sizeof( sz ) );
    if( sz != 0 ) f.Write( m_threadExpand.data(), sz * sizeof( uint64_t ) );
}

uint16_t ThreadCompress::CompressThreadReal( uint64_t thread )
{
    auto it = m_threadMap.find( thread );
    if( it != m_threadMap.end() )
    {
        m_threadLast.first = thread;
        m_threadLast.second = it->second;
        return it->second;
    }
    else
    {
        return CompressThreadNew( thread );
    }
}

uint16_t ThreadCompress::CompressThreadNew( uint64_t thread )
{
    auto sz = m_threadExpand.size();
    m_threadExpand.push_back( thread );
    m_threadMap.emplace( thread, sz );
    m_threadLast.first = thread;
    m_threadLast.second = sz;
    return sz;
}

}