//==============================================================================
bool Thread::setPriority (const int newPriority)
{
// NB: deadlock possible if you try to set the thread prio from the thread itself,
// so using setCurrentThreadPriority instead in that case.
if (getCurrentThreadId() == getThreadId())
return setCurrentThreadPriority (newPriority);
const RecursiveMutex::ScopedLockType sl (startStopLock);
if (setThreadPriority (threadHandle, newPriority))
{
threadPriority = newPriority;
return true;
}
return false;
}
CL_BOOL CL_ThreadUnix::SetPriorityExt(INT pri)
{
if (!m_tid)
{
return CL_FALSE;
}
#if defined(_FOR_ANDROID_) || defined (_LINUX)
int ret = setpriority(PRIO_PROCESS, m_dwThreadID, pri);
if (ret < 0)
{
CL_PERROR("<<<< Set thread [%s][%lu, 0x%x] priority : %d failed, ret = %d [%s].", m_szThreadName, m_dwThreadID, static_cast<UINT>(m_dwThreadID), pri, ret, strerror(ret));
}
#elif defined _FOR_APPLE_
if (m_dwThreadID != (DWORD)gettid())
{
return CL_FALSE;
}
double macpri = (double)pri;
setCurrentThreadPriority(macpri);
#endif
return CL_TRUE;
}
void TileWorker::run() {
setCurrentThreadPriority(WORKER_NICENESS);
StyleContext context;
while (true) {
std::shared_ptr<TileTask> task;
{
std::unique_lock<std::mutex> lock(m_mutex);
m_condition.wait(lock, [&, this]{
return !m_running || !m_queue.empty();
});
// Check if thread should stop
if (!m_running) {
break;
}
// Remove all canceled tasks
auto removes = std::remove_if(m_queue.begin(), m_queue.end(),
[](const auto& a) { return a->isCanceled(); });
m_queue.erase(removes, m_queue.end());
if (m_queue.empty()) {
continue;
}
// Pop highest priority tile from queue
auto it = std::min_element(m_queue.begin(), m_queue.end(),
[](const auto& a, const auto& b) {
if (a->isProxy() != b->isProxy()) {
return !a->isProxy();
}
if (a->source().id() == b->source().id() &&
a->sourceGeneration() != b->sourceGeneration()) {
return a->sourceGeneration() < b->sourceGeneration();
}
return a->getPriority() < b->getPriority();
});
task = std::move(*it);
m_queue.erase(it);
}
if (task->isCanceled()) { continue; }
// Save shared reference to Scene while building tile
// FIXME: Scene could be released on Worker-Thread and
// therefore call unsafe glDelete* functions...
auto scene = m_scene;
if (!scene) { continue; }
auto tileData = task->source().parse(*task, *scene->mapProjection());
// const clock_t begin = clock();
context.initFunctions(*scene);
if (tileData) {
auto tile = std::make_shared<Tile>(task->tileId(),
*scene->mapProjection(),
&task->source());
tile->build(context, *scene, *tileData, task->source());
// Mark task as ready
task->setTile(std::move(tile));
// float loadTime = (float(clock() - begin) / CLOCKS_PER_SEC) * 1000;
// LOG("loadTime %s - %f", task->tile()->getID().toString().c_str(), loadTime);
} else {
task->cancel();
}
m_pendingTiles = true;
requestRender();
}
}
void TileWorker::run(Worker* instance) {
setCurrentThreadPriority(WORKER_NICENESS);
std::unique_ptr<TileBuilder> builder;
while (true) {
std::shared_ptr<TileTask> task;
{
std::unique_lock<std::mutex> lock(m_mutex);
m_condition.wait(lock, [&, this]{
return !m_running || !m_queue.empty();
});
if (instance->tileBuilder) {
disposeBuilder(std::move(builder));
builder = std::move(instance->tileBuilder);
LOG("Passed new TileBuilder to TileWorker");
}
// Check if thread should stop
if (!m_running) {
disposeBuilder(std::move(builder));
break;
}
if (!builder) {
LOGE("Missing Scene/StyleContext in TileWorker!");
continue;
}
// Remove all canceled tasks
auto removes = std::remove_if(m_queue.begin(), m_queue.end(),
[](const auto& a) { return a->isCanceled(); });
m_queue.erase(removes, m_queue.end());
if (m_queue.empty()) {
continue;
}
// Pop highest priority tile from queue
auto it = std::min_element(m_queue.begin(), m_queue.end(),
[](const auto& a, const auto& b) {
if (a->isProxy() != b->isProxy()) {
return !a->isProxy();
}
if (a->source().id() == b->source().id() &&
a->sourceGeneration() != b->sourceGeneration()) {
return a->sourceGeneration() < b->sourceGeneration();
}
return a->getPriority() < b->getPriority();
});
task = std::move(*it);
m_queue.erase(it);
}
if (task->isCanceled()) {
continue;
}
auto tileData = task->source().parse(*task, *builder->scene().mapProjection());
// const clock_t begin = clock();
if (tileData) {
auto&& tile = builder->build(task->tileId(), *tileData, task->source());
// Mark task as ready
task->setTile(std::move(tile));
// float loadTime = (float(clock() - begin) / CLOCKS_PER_SEC) * 1000;
// LOG("loadTime %s - %f", task->tile()->getID().toString().c_str(), loadTime);
} else {
task->cancel();
}
m_pendingTiles = true;
requestRender();
}
}
void TileWorker::run() {
setCurrentThreadPriority(WORKER_NICENESS);
StyleContext context;
while (true) {
std::shared_ptr<TileTask> task;
{
std::unique_lock<std::mutex> lock(m_mutex);
m_condition.wait(lock, [&, this]{
return !m_running || !m_queue.empty();
});
// Check if thread should stop
if (!m_running) {
break;
}
// Remove all canceled tasks
auto removes = std::remove_if(m_queue.begin(), m_queue.end(),
[](const auto& a) { return a->tile->isCanceled(); });
m_queue.erase(removes, m_queue.end());
if (m_queue.empty()) {
continue;
}
// Pop highest priority tile from queue
auto it = std::min_element(m_queue.begin(), m_queue.end(),
[](const auto& a, const auto& b) {
if (a->tile->isVisible() != b->tile->isVisible()) {
return a->tile->isVisible();
}
return a->tile->getPriority() < b->tile->getPriority();
});
task = std::move(*it);
m_queue.erase(it);
}
if (task->tile->isCanceled()) {
continue;
}
auto tileData = task->process();
// NB: Save shared reference to Scene while building tile
auto scene = m_tileManager.getScene();
const clock_t begin = clock();
context.initFunctions(*scene);
if (tileData) {
task->tile->build(context, *scene, *tileData, *task->source);
float loadTime = (float(clock() - begin) / CLOCKS_PER_SEC) * 1000;
LOG("loadTime %s - %f", task->tile->getID().toString().c_str(), loadTime);
m_tileManager.tileProcessed(std::move(task));
}
requestRender();
}
}
