src/emerge.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21
  22 #include "emerge.h"
  23
  24 #include <iostream>
  25 #include <queue>
  26
  27 #include "util/container.h"
  28 #include "util/thread.h"
  29 #include "threading/event.h"
  30
  31 #include "config.h"
  32 #include "constants.h"
  33 #include "environment.h"
  34 #include "log.h"
  35 #include "map.h"
  36 #include "mapblock.h"
  37 #include "mapgen/mg_biome.h"
  38 #include "mapgen/mg_ore.h"
  39 #include "mapgen/mg_decoration.h"
  40 #include "mapgen/mg_schematic.h"
  41 #include "nodedef.h"
  42 #include "profiler.h"
  43 #include "scripting_server.h"
  44 #include "server.h"
  45 #include "settings.h"
  46 #include "voxel.h"
  47
  48 class EmergeThread : public Thread {
  49 public:
  50         bool enable_mapgen_debug_info;
  51         int id;
  52
  53         EmergeThread(Server *server, int ethreadid);
  54         ~EmergeThread() = default;
  55
  56         void *run();
  57         void signal();
  58
  59         // Requires queue mutex held
  60         bool pushBlock(const v3s16 &pos);
  61
  62         void cancelPendingItems();
  63
  64         static void runCompletionCallbacks(
  65                 const v3s16 &pos, EmergeAction action,
  66                 const EmergeCallbackList &callbacks);
  67
  68 private:
  69         Server *m_server;
  70         ServerMap *m_map;
  71         EmergeManager *m_emerge;
  72         Mapgen *m_mapgen;
  73
  74         Event m_queue_event;
  75         std::queue<v3s16> m_block_queue;
  76
  77         bool popBlockEmerge(v3s16 *pos, BlockEmergeData *bedata);
  78
  79         EmergeAction getBlockOrStartGen(
  80                 const v3s16 &pos, bool allow_gen, MapBlock **block, BlockMakeData *data);
  81         MapBlock *finishGen(v3s16 pos, BlockMakeData *bmdata,
  82                 std::map<v3s16, MapBlock *> *modified_blocks);
  83
  84         friend class EmergeManager;
  85 };
  86
  87 class MapEditEventAreaIgnorer
  88 {
  89 public:
  90         MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a):
  91                 m_ignorevariable(ignorevariable)
  92         {
  93                 if(m_ignorevariable->getVolume() == 0)
  94                         *m_ignorevariable = a;
  95                 else
  96                         m_ignorevariable = NULL;
  97         }
  98
  99         ~MapEditEventAreaIgnorer()
 100         {
 101                 if(m_ignorevariable)
 102                 {
 103                         assert(m_ignorevariable->getVolume() != 0);
 104                         *m_ignorevariable = VoxelArea();
 105                 }
 106         }
 107
 108 private:
 109         VoxelArea *m_ignorevariable;
 110 };
 111
 112 ////
 113 //// EmergeManager
 114 ////
 115
 116 EmergeManager::EmergeManager(Server *server)
 117 {
 118         this->ndef      = server->getNodeDefManager();
 119         this->biomemgr  = new BiomeManager(server);
 120         this->oremgr    = new OreManager(server);
 121         this->decomgr   = new DecorationManager(server);
 122         this->schemmgr  = new SchematicManager(server);
 123
 124         // Note that accesses to this variable are not synchronized.
 125         // This is because the *only* thread ever starting or stopping
 126         // EmergeThreads should be the ServerThread.
 127
 128         enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
 129
 130         s16 nthreads = 1;
 131         g_settings->getS16NoEx("num_emerge_threads", nthreads);
 132         // If automatic, leave a proc for the main thread and one for
 133         // some other misc thread
 134         if (nthreads == 0)
 135                 nthreads = Thread::getNumberOfProcessors() - 2;
 136         if (nthreads < 1)
 137                 nthreads = 1;
 138
 139         m_qlimit_total = g_settings->getU16("emergequeue_limit_total");
 140         if (!g_settings->getU16NoEx("emergequeue_limit_diskonly", m_qlimit_diskonly))
 141                 m_qlimit_diskonly = nthreads * 5 + 1;
 142         if (!g_settings->getU16NoEx("emergequeue_limit_generate", m_qlimit_generate))
 143                 m_qlimit_generate = nthreads + 1;
 144
 145         // don't trust user input for something very important like this
 146         if (m_qlimit_total < 1)
 147                 m_qlimit_total = 1;
 148         if (m_qlimit_diskonly < 1)
 149                 m_qlimit_diskonly = 1;
 150         if (m_qlimit_generate < 1)
 151                 m_qlimit_generate = 1;
 152
 153         for (s16 i = 0; i < nthreads; i++)
 154                 m_threads.push_back(new EmergeThread(server, i));
 155
 156         infostream << "EmergeManager: using " << nthreads << " threads" << std::endl;
 157 }
 158
 159
 160 EmergeManager::~EmergeManager()
 161 {
 162         for (u32 i = 0; i != m_threads.size(); i++) {
 163                 EmergeThread *thread = m_threads[i];
 164
 165                 if (m_threads_active) {
 166                         thread->stop();
 167                         thread->signal();
 168                         thread->wait();
 169                 }
 170
 171                 delete thread;
 172
 173                 // Mapgen init might not be finished if there is an error during startup.
 174                 if (m_mapgens.size() > i)
 175                         delete m_mapgens[i];
 176         }
 177
 178         delete biomemgr;
 179         delete oremgr;
 180         delete decomgr;
 181         delete schemmgr;
 182 }
 183
 184
 185 void EmergeManager::initMapgens(MapgenParams *params)
 186 {
 187         FATAL_ERROR_IF(!m_mapgens.empty(), "Mapgen already initialised.");
 188
 189         mgparams = params;
 190
 191         for (u32 i = 0; i != m_threads.size(); i++)
 192                 m_mapgens.push_back(Mapgen::createMapgen(params->mgtype, params, this));
 193 }
 194
 195
 196 Mapgen *EmergeManager::getCurrentMapgen()
 197 {
 198         if (!m_threads_active)
 199                 return nullptr;
 200
 201         for (u32 i = 0; i != m_threads.size(); i++) {
 202                 if (m_threads[i]->isCurrentThread())
 203                         return m_threads[i]->m_mapgen;
 204         }
 205
 206         return nullptr;
 207 }
 208
 209
 210 void EmergeManager::startThreads()
 211 {
 212         if (m_threads_active)
 213                 return;
 214
 215         for (u32 i = 0; i != m_threads.size(); i++)
 216                 m_threads[i]->start();
 217
 218         m_threads_active = true;
 219 }
 220
 221
 222 void EmergeManager::stopThreads()
 223 {
 224         if (!m_threads_active)
 225                 return;
 226
 227         // Request thread stop in parallel
 228         for (u32 i = 0; i != m_threads.size(); i++) {
 229                 m_threads[i]->stop();
 230                 m_threads[i]->signal();
 231         }
 232
 233         // Then do the waiting for each
 234         for (u32 i = 0; i != m_threads.size(); i++)
 235                 m_threads[i]->wait();
 236
 237         m_threads_active = false;
 238 }
 239
 240
 241 bool EmergeManager::isRunning()
 242 {
 243         return m_threads_active;
 244 }
 245
 246
 247 bool EmergeManager::enqueueBlockEmerge(
 248         session_t peer_id,
 249         v3s16 blockpos,
 250         bool allow_generate,
 251         bool ignore_queue_limits)
 252 {
 253         u16 flags = 0;
 254         if (allow_generate)
 255                 flags |= BLOCK_EMERGE_ALLOW_GEN;
 256         if (ignore_queue_limits)
 257                 flags |= BLOCK_EMERGE_FORCE_QUEUE;
 258
 259         return enqueueBlockEmergeEx(blockpos, peer_id, flags, NULL, NULL);
 260 }
 261
 262
 263 bool EmergeManager::enqueueBlockEmergeEx(
 264         v3s16 blockpos,
 265         session_t peer_id,
 266         u16 flags,
 267         EmergeCompletionCallback callback,
 268         void *callback_param)
 269 {
 270         EmergeThread *thread = NULL;
 271         bool entry_already_exists = false;
 272
 273         {
 274                 MutexAutoLock queuelock(m_queue_mutex);
 275
 276                 if (!pushBlockEmergeData(blockpos, peer_id, flags,
 277                                 callback, callback_param, &entry_already_exists))
 278                         return false;
 279
 280                 if (entry_already_exists)
 281                         return true;
 282
 283                 thread = getOptimalThread();
 284                 thread->pushBlock(blockpos);
 285         }
 286
 287         thread->signal();
 288
 289         return true;
 290 }
 291
 292
 293 //
 294 // Mapgen-related helper functions
 295 //
 296
 297
 298 // TODO(hmmmm): Move this to ServerMap
 299 v3s16 EmergeManager::getContainingChunk(v3s16 blockpos)
 300 {
 301         return getContainingChunk(blockpos, mgparams->chunksize);
 302 }
 303
 304 // TODO(hmmmm): Move this to ServerMap
 305 v3s16 EmergeManager::getContainingChunk(v3s16 blockpos, s16 chunksize)
 306 {
 307         s16 coff = -chunksize / 2;
 308         v3s16 chunk_offset(coff, coff, coff);
 309
 310         return getContainerPos(blockpos - chunk_offset, chunksize)
 311                 * chunksize + chunk_offset;
 312 }
 313
 314
 315 int EmergeManager::getSpawnLevelAtPoint(v2s16 p)
 316 {
 317         if (m_mapgens.empty() || !m_mapgens[0]) {
 318                 errorstream << "EmergeManager: getSpawnLevelAtPoint() called"
 319                         " before mapgen init" << std::endl;
 320                 return 0;
 321         }
 322
 323         return m_mapgens[0]->getSpawnLevelAtPoint(p);
 324 }
 325
 326
 327 int EmergeManager::getGroundLevelAtPoint(v2s16 p)
 328 {
 329         if (m_mapgens.empty() || !m_mapgens[0]) {
 330                 errorstream << "EmergeManager: getGroundLevelAtPoint() called"
 331                         " before mapgen init" << std::endl;
 332                 return 0;
 333         }
 334
 335         return m_mapgens[0]->getGroundLevelAtPoint(p);
 336 }
 337
 338 // TODO(hmmmm): Move this to ServerMap
 339 bool EmergeManager::isBlockUnderground(v3s16 blockpos)
 340 {
 341 #if 0
 342         v2s16 p = v2s16((blockpos.X * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2,
 343                                         (blockpos.Y * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2);
 344         int ground_level = getGroundLevelAtPoint(p);
 345         return blockpos.Y * (MAP_BLOCKSIZE + 1) <= min(water_level, ground_level);
 346 #endif
 347
 348         // Use a simple heuristic; the above method is wildly inaccurate anyway.
 349         return blockpos.Y * (MAP_BLOCKSIZE + 1) <= mgparams->water_level;
 350 }
 351
 352 bool EmergeManager::pushBlockEmergeData(
 353         v3s16 pos,
 354         u16 peer_requested,
 355         u16 flags,
 356         EmergeCompletionCallback callback,
 357         void *callback_param,
 358         bool *entry_already_exists)
 359 {
 360         u16 &count_peer = m_peer_queue_count[peer_requested];
 361
 362         if ((flags & BLOCK_EMERGE_FORCE_QUEUE) == 0) {
 363                 if (m_blocks_enqueued.size() >= m_qlimit_total)
 364                         return false;
 365
 366                 if (peer_requested != PEER_ID_INEXISTENT) {
 367                         u16 qlimit_peer = (flags & BLOCK_EMERGE_ALLOW_GEN) ?
 368                                 m_qlimit_generate : m_qlimit_diskonly;
 369                         if (count_peer >= qlimit_peer)
 370                                 return false;
 371                 }
 372         }
 373
 374         std::pair<std::map<v3s16, BlockEmergeData>::iterator, bool> findres;
 375         findres = m_blocks_enqueued.insert(std::make_pair(pos, BlockEmergeData()));
 376
 377         BlockEmergeData &bedata = findres.first->second;
 378         *entry_already_exists   = !findres.second;
 379
 380         if (callback)
 381                 bedata.callbacks.emplace_back(callback, callback_param);
 382
 383         if (*entry_already_exists) {
 384                 bedata.flags |= flags;
 385         } else {
 386                 bedata.flags = flags;
 387                 bedata.peer_requested = peer_requested;
 388
 389                 count_peer++;
 390         }
 391
 392         return true;
 393 }
 394
 395
 396 bool EmergeManager::popBlockEmergeData(v3s16 pos, BlockEmergeData *bedata)
 397 {
 398         std::map<v3s16, BlockEmergeData>::iterator it;
 399         std::unordered_map<u16, u16>::iterator it2;
 400
 401         it = m_blocks_enqueued.find(pos);
 402         if (it == m_blocks_enqueued.end())
 403                 return false;
 404
 405         *bedata = it->second;
 406
 407         it2 = m_peer_queue_count.find(bedata->peer_requested);
 408         if (it2 == m_peer_queue_count.end())
 409                 return false;
 410
 411         u16 &count_peer = it2->second;
 412         assert(count_peer != 0);
 413         count_peer--;
 414
 415         m_blocks_enqueued.erase(it);
 416
 417         return true;
 418 }
 419
 420
 421 EmergeThread *EmergeManager::getOptimalThread()
 422 {
 423         size_t nthreads = m_threads.size();
 424
 425         FATAL_ERROR_IF(nthreads == 0, "No emerge threads!");
 426
 427         size_t index = 0;
 428         size_t nitems_lowest = m_threads[0]->m_block_queue.size();
 429
 430         for (size_t i = 1; i < nthreads; i++) {
 431                 size_t nitems = m_threads[i]->m_block_queue.size();
 432                 if (nitems < nitems_lowest) {
 433                         index = i;
 434                         nitems_lowest = nitems;
 435                 }
 436         }
 437
 438         return m_threads[index];
 439 }
 440
 441
 442 ////
 443 //// EmergeThread
 444 ////
 445
 446 EmergeThread::EmergeThread(Server *server, int ethreadid) :
 447         enable_mapgen_debug_info(false),
 448         id(ethreadid),
 449         m_server(server),
 450         m_map(NULL),
 451         m_emerge(NULL),
 452         m_mapgen(NULL)
 453 {
 454         m_name = "Emerge-" + itos(ethreadid);
 455 }
 456
 457
 458 void EmergeThread::signal()
 459 {
 460         m_queue_event.signal();
 461 }
 462
 463
 464 bool EmergeThread::pushBlock(const v3s16 &pos)
 465 {
 466         m_block_queue.push(pos);
 467         return true;
 468 }
 469
 470
 471 void EmergeThread::cancelPendingItems()
 472 {
 473         MutexAutoLock queuelock(m_emerge->m_queue_mutex);
 474
 475         while (!m_block_queue.empty()) {
 476                 BlockEmergeData bedata;
 477                 v3s16 pos;
 478
 479                 pos = m_block_queue.front();
 480                 m_block_queue.pop();
 481
 482                 m_emerge->popBlockEmergeData(pos, &bedata);
 483
 484                 runCompletionCallbacks(pos, EMERGE_CANCELLED, bedata.callbacks);
 485         }
 486 }
 487
 488
 489 void EmergeThread::runCompletionCallbacks(const v3s16 &pos, EmergeAction action,
 490         const EmergeCallbackList &callbacks)
 491 {
 492         for (size_t i = 0; i != callbacks.size(); i++) {
 493                 EmergeCompletionCallback callback;
 494                 void *param;
 495
 496                 callback = callbacks[i].first;
 497                 param    = callbacks[i].second;
 498
 499                 callback(pos, action, param);
 500         }
 501 }
 502
 503
 504 bool EmergeThread::popBlockEmerge(v3s16 *pos, BlockEmergeData *bedata)
 505 {
 506         MutexAutoLock queuelock(m_emerge->m_queue_mutex);
 507
 508         if (m_block_queue.empty())
 509                 return false;
 510
 511         *pos = m_block_queue.front();
 512         m_block_queue.pop();
 513
 514         m_emerge->popBlockEmergeData(*pos, bedata);
 515
 516         return true;
 517 }
 518
 519
 520 EmergeAction EmergeThread::getBlockOrStartGen(
 521         const v3s16 &pos, bool allow_gen, MapBlock **block, BlockMakeData *bmdata)
 522 {
 523         MutexAutoLock envlock(m_server->m_env_mutex);
 524
 525         // 1). Attempt to fetch block from memory
 526         *block = m_map->getBlockNoCreateNoEx(pos);
 527         if (*block && !(*block)->isDummy()) {
 528                 if ((*block)->isGenerated())
 529                         return EMERGE_FROM_MEMORY;
 530         } else {
 531                 // 2). Attempt to load block from disk if it was not in the memory
 532                 *block = m_map->loadBlock(pos);
 533                 if (*block && (*block)->isGenerated())
 534                         return EMERGE_FROM_DISK;
 535         }
 536
 537         // 3). Attempt to start generation
 538         if (allow_gen && m_map->initBlockMake(pos, bmdata))
 539                 return EMERGE_GENERATED;
 540
 541         // All attempts failed; cancel this block emerge
 542         return EMERGE_CANCELLED;
 543 }
 544
 545
 546 MapBlock *EmergeThread::finishGen(v3s16 pos, BlockMakeData *bmdata,
 547         std::map<v3s16, MapBlock *> *modified_blocks)
 548 {
 549         MutexAutoLock envlock(m_server->m_env_mutex);
 550         ScopeProfiler sp(g_profiler,
 551                 "EmergeThread: after Mapgen::makeChunk", SPT_AVG);
 552
 553         /*
 554                 Perform post-processing on blocks (invalidate lighting, queue liquid
 555                 transforms, etc.) to finish block make
 556         */
 557         m_map->finishBlockMake(bmdata, modified_blocks);
 558
 559         MapBlock *block = m_map->getBlockNoCreateNoEx(pos);
 560         if (!block) {
 561                 errorstream << "EmergeThread::finishGen: Couldn't grab block we "
 562                         "just generated: " << PP(pos) << std::endl;
 563                 return NULL;
 564         }
 565
 566         v3s16 minp = bmdata->blockpos_min * MAP_BLOCKSIZE;
 567         v3s16 maxp = bmdata->blockpos_max * MAP_BLOCKSIZE +
 568                                  v3s16(1,1,1) * (MAP_BLOCKSIZE - 1);
 569
 570         // Ignore map edit events, they will not need to be sent
 571         // to anybody because the block hasn't been sent to anybody
 572         MapEditEventAreaIgnorer ign(
 573                 &m_server->m_ignore_map_edit_events_area,
 574                 VoxelArea(minp, maxp));
 575
 576         /*
 577                 Run Lua on_generated callbacks
 578         */
 579         try {
 580                 m_server->getScriptIface()->environment_OnGenerated(
 581                         minp, maxp, m_mapgen->blockseed);
 582         } catch (LuaError &e) {
 583                 m_server->setAsyncFatalError("Lua: finishGen" + std::string(e.what()));
 584         }
 585
 586         /*
 587                 Clear generate notifier events
 588         */
 589         Mapgen *mg = m_emerge->getCurrentMapgen();
 590         mg->gennotify.clearEvents();
 591
 592         EMERGE_DBG_OUT("ended up with: " << analyze_block(block));
 593
 594         /*
 595                 Activate the block
 596         */
 597         m_server->m_env->activateBlock(block, 0);
 598
 599         return block;
 600 }
 601
 602
 603 void *EmergeThread::run()
 604 {
 605         BEGIN_DEBUG_EXCEPTION_HANDLER
 606
 607         v3s16 pos;
 608
 609         m_map    = (ServerMap *)&(m_server->m_env->getMap());
 610         m_emerge = m_server->m_emerge;
 611         m_mapgen = m_emerge->m_mapgens[id];
 612         enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info;
 613
 614         try {
 615         while (!stopRequested()) {
 616                 std::map<v3s16, MapBlock *> modified_blocks;
 617                 BlockEmergeData bedata;
 618                 BlockMakeData bmdata;
 619                 EmergeAction action;
 620                 MapBlock *block;
 621
 622                 if (!popBlockEmerge(&pos, &bedata)) {
 623                         m_queue_event.wait();
 624                         continue;
 625                 }
 626
 627                 if (blockpos_over_max_limit(pos))
 628                         continue;
 629
 630                 bool allow_gen = bedata.flags & BLOCK_EMERGE_ALLOW_GEN;
 631                 EMERGE_DBG_OUT("pos=" PP(pos) " allow_gen=" << allow_gen);
 632
 633                 action = getBlockOrStartGen(pos, allow_gen, &block, &bmdata);
 634                 if (action == EMERGE_GENERATED) {
 635                         {
 636                                 ScopeProfiler sp(g_profiler,
 637                                         "EmergeThread: Mapgen::makeChunk", SPT_AVG);
 638
 639                                 m_mapgen->makeChunk(&bmdata);
 640                         }
 641
 642                         block = finishGen(pos, &bmdata, &modified_blocks);
 643                 }
 644
 645                 runCompletionCallbacks(pos, action, bedata.callbacks);
 646
 647                 if (block)
 648                         modified_blocks[pos] = block;
 649
 650                 if (!modified_blocks.empty())
 651                         m_server->SetBlocksNotSent(modified_blocks);
 652         }
 653         } catch (VersionMismatchException &e) {
 654                 std::ostringstream err;
 655                 err << "World data version mismatch in MapBlock " << PP(pos) << std::endl
 656                         << "----" << std::endl
 657                         << "\"" << e.what() << "\"" << std::endl
 658                         << "See debug.txt." << std::endl
 659                         << "World probably saved by a newer version of " PROJECT_NAME_C "."
 660                         << std::endl;
 661                 m_server->setAsyncFatalError(err.str());
 662         } catch (SerializationError &e) {
 663                 std::ostringstream err;
 664                 err << "Invalid data in MapBlock " << PP(pos) << std::endl
 665                         << "----" << std::endl
 666                         << "\"" << e.what() << "\"" << std::endl
 667                         << "See debug.txt." << std::endl
 668                         << "You can ignore this using [ignore_world_load_errors = true]."
 669                         << std::endl;
 670                 m_server->setAsyncFatalError(err.str());
 671         }
 672
 673         END_DEBUG_EXCEPTION_HANDLER
 674         return NULL;
 675 }