#include "MapUpdater.h"

Public Member Functions
	MapUpdater ()

	~MapUpdater ()=default

void	schedule_update (Map &map, uint32 diff, uint32 s_diff)

void	schedule_lfg_update (uint32 diff)

void	wait ()

void	activate (std::size_t num_threads)

void	deactivate ()

bool	activated ()

void	update_finished ()

Private Member Functions
void	WorkerThread ()

Private Attributes
ProducerConsumerQueue< UpdateRequest * >	_queue

std::vector< std::thread >	_workerThreads

std::atomic< bool >	_cancelationToken

std::mutex	_lock

std::condition_variable	_condition

std::size_t	pending_requests

Detailed Description

Constructor & Destructor Documentation

◆ MapUpdater()

MapUpdater::MapUpdater ( )

                      : pending_requests(0)
{
}

◆ ~MapUpdater()

MapUpdater::~MapUpdater ( )

default

Member Function Documentation

◆ activate()

void MapUpdater::activate ( std::size_t num_threads )

{
    _workerThreads.reserve(num_threads);
    for (std::size_t i = 0; i < num_threads; ++i)
    {
        _workerThreads.push_back(std::thread(&MapUpdater::WorkerThread, this));
    }
}

References _workerThreads, and WorkerThread().

Referenced by MapMgr::Initialize().

◆ activated()

bool MapUpdater::activated ( )

{
    return _workerThreads.size() > 0;
}

References _workerThreads.

Referenced by MapMgr::UnloadAll(), and MapMgr::Update().

◆ deactivate()

void MapUpdater::deactivate ( )

{
    _cancelationToken = true;
 
    wait();
 
    _queue.Cancel();
 
    for (auto& thread : _workerThreads)
    {
        if (thread.joinable())
        {
            thread.join();
        }
    }
}

References _cancelationToken, _queue, _workerThreads, ProducerConsumerQueue< T >::Cancel(), and wait().

Referenced by MapMgr::UnloadAll().

◆ schedule_lfg_update()

void MapUpdater::schedule_lfg_update ( uint32 diff )

{
    std::lock_guard<std::mutex> guard(_lock);
 
    ++pending_requests;
 
    _queue.Push(new LFGUpdateRequest(*this, diff));
}

References _lock, _queue, pending_requests, and ProducerConsumerQueue< T >::Push().

Referenced by MapMgr::Update().

◆ schedule_update()

void MapUpdater::schedule_update	(	Map &	map,
		uint32	diff,
		uint32	s_diff
	)

{
    std::lock_guard<std::mutex> guard(_lock);
 
    ++pending_requests;
 
    _queue.Push(new MapUpdateRequest(map, *this, diff, s_diff));
}

References _lock, _queue, pending_requests, and ProducerConsumerQueue< T >::Push().

Referenced by MapMgr::Update().

◆ update_finished()

void MapUpdater::update_finished ( )

{
    std::lock_guard<std::mutex> lock(_lock);
 
    --pending_requests;
 
    _condition.notify_all();
}

References _condition, _lock, and pending_requests.

Referenced by MapUpdateRequest::call(), and LFGUpdateRequest::call().

◆ wait()

void MapUpdater::wait ( )

{
    std::unique_lock<std::mutex> guard(_lock);
 
    while (pending_requests > 0)
        _condition.wait(guard);
 
    guard.unlock();
}

References _condition, _lock, and pending_requests.

Referenced by deactivate(), and MapMgr::Update().

◆ WorkerThread()

void MapUpdater::WorkerThread ( )

private

{
    LoginDatabase.WarnAboutSyncQueries(true);
    CharacterDatabase.WarnAboutSyncQueries(true);
    WorldDatabase.WarnAboutSyncQueries(true);
 
    while (1)
    {
        UpdateRequest* request = nullptr;
 
        _queue.WaitAndPop(request);
        if (_cancelationToken)
            return;
 
        request->call();
 
        delete request;
    }
}