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