MapUpdater Class Reference

#include "MapUpdater.h"

Public Member Functions
	MapUpdater ()
	~MapUpdater ()=default
void	schedule_task (UpdateRequest *request)
void	schedule_update (Map &map, uint32 diff, uint32 s_diff)
void	schedule_map_preload (uint32 mapid)
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::atomic< int >	pending_requests
std::atomic< bool >	_cancelationToken
std::vector< std::thread >	_workerThreads
std::mutex	_lock
std::condition_variable	_condition

Detailed Description

Constructor & Destructor Documentation

MapUpdater()

MapUpdater::MapUpdater

(

)

                       : pending_requests(0), _cancelationToken(false)
{
}

~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.empty();
}

References _workerThreads.

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

deactivate()

void MapUpdater::deactivate

(

)

{
    _cancelationToken = true;
 
    wait();  // This is where we wait for tasks to complete
 
    _queue.Cancel();  // Cancel the queue to prevent further task processing
 
    // Join all worker threads
    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

)

{
    schedule_task(new LFGUpdateRequest(*this, diff));
}

References schedule_task().

Referenced by MapMgr::Update().

schedule_map_preload()

void MapUpdater::schedule_map_preload

(

uint32

mapid

)

{
    schedule_task(new MapPreloadRequest(mapid, *this));
}

References schedule_task().

schedule_task()

void MapUpdater::schedule_task

(

UpdateRequest *

request

)

{
    // Atomic increment for pending_requests
    pending_requests.fetch_add(1, std::memory_order_release);
    _queue.Push(request);
}

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

Referenced by schedule_lfg_update(), schedule_map_preload(), and schedule_update().

schedule_update()

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

{
    schedule_task(new MapUpdateRequest(map, *this, diff, s_diff));
}

References schedule_task().

Referenced by MapMgr::Update().

update_finished()

void MapUpdater::update_finished

(

)

{
    // Atomic decrement for pending_requests
    if (pending_requests.fetch_sub(1, std::memory_order_acquire) == 1)
    {
        // Only notify when pending_requests becomes 0 (i.e., all tasks are finished)
        std::lock_guard<std::mutex> lock(_lock);  // Lock only for condition variable notification
        _condition.notify_all();  // Notify waiting threads that all requests are complete
    }
}

References _condition, _lock, and pending_requests.

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

wait()

void MapUpdater::wait

(

)

{
    std::unique_lock<std::mutex> guard(_lock);  // Guard lock for safe waiting
 
    // Wait until there are no pending requests
    _condition.wait(guard, [this] {
        return pending_requests.load(std::memory_order_acquire) == 0;
    });
}

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 (!_cancelationToken)
    {
        UpdateRequest* request = nullptr;
 
        _queue.WaitAndPop(request);  // Wait for and pop a request from the queue
 
        if (!_cancelationToken && request)
        {
            request->call();  // Execute the request
            delete request;  // Clean up after processing
        }
    }
}

References _cancelationToken, _queue, UpdateRequest::call(), CharacterDatabase, LoginDatabase, ProducerConsumerQueue< T >::WaitAndPop(), and WorldDatabase.

Referenced by activate().

Member Data Documentation

_cancelationToken

std::atomic<bool> MapUpdater::_cancelationToken

private

Referenced by deactivate(), and WorkerThread().

_condition

std::condition_variable MapUpdater::_condition

private

Referenced by update_finished(), and wait().

_lock

std::mutex MapUpdater::_lock

private

Referenced by update_finished(), and wait().

_queue

ProducerConsumerQueue<UpdateRequest*> MapUpdater::_queue

private

Referenced by deactivate(), schedule_task(), and WorkerThread().

_workerThreads

std::vector<std::thread> MapUpdater::_workerThreads

private

Referenced by activate(), activated(), and deactivate().

pending_requests

std::atomic<int> MapUpdater::pending_requests

private

Referenced by schedule_task(), update_finished(), and wait().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Maps/MapUpdater.h
• azerothcore-wotlk/src/server/game/Maps/MapUpdater.cpp