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_game.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         for (u32 i = 0; i != m_threads.size(); i++) {
 178                 if (m_threads[i]->isCurrentThread())
 179                         return m_threads[i]->m_mapgen;
 180         }
 181
 182         return NULL;
 183 }
 184
 185
 186 void EmergeManager::startThreads()
 187 {
 188         if (m_threads_active)
 189                 return;
 190
 191         for (u32 i = 0; i != m_threads.size(); i++)
 192                 m_threads[i]->start();
 193
 194         m_threads_active = true;
 195 }
 196
 197
 198 void EmergeManager::stopThreads()
 199 {
 200         if (!m_threads_active)
 201                 return;
 202
 203         // Request thread stop in parallel
 204         for (u32 i = 0; i != m_threads.size(); i++) {
 205                 m_threads[i]->stop();
 206                 m_threads[i]->signal();
 207         }
 208
 209         // Then do the waiting for each
 210         for (u32 i = 0; i != m_threads.size(); i++)
 211                 m_threads[i]->wait();
 212
 213         m_threads_active = false;
 214 }
 215
 216
 217 bool EmergeManager::isRunning()
 218 {
 219         return m_threads_active;
 220 }
 221
 222
 223 bool EmergeManager::enqueueBlockEmerge(
 224         u16 peer_id,
 225         v3s16 blockpos,
 226         bool allow_generate,
 227         bool ignore_queue_limits)
 228 {
 229         u16 flags = 0;
 230         if (allow_generate)
 231                 flags |= BLOCK_EMERGE_ALLOW_GEN;
 232         if (ignore_queue_limits)
 233                 flags |= BLOCK_EMERGE_FORCE_QUEUE;
 234
 235         return enqueueBlockEmergeEx(blockpos, peer_id, flags, NULL, NULL);
 236 }
 237
 238
 239 bool EmergeManager::enqueueBlockEmergeEx(
 240         v3s16 blockpos,
 241         u16 peer_id,
 242         u16 flags,
 243         EmergeCompletionCallback callback,
 244         void *callback_param)
 245 {
 246         EmergeThread *thread = NULL;
 247         bool entry_already_exists = false;
 248
 249         {
 250                 MutexAutoLock queuelock(m_queue_mutex);
 251
 252                 if (!pushBlockEmergeData(blockpos, peer_id, flags,
 253                                 callback, callback_param, &entry_already_exists))
 254                         return false;
 255
 256                 if (entry_already_exists)
 257                         return true;
 258
 259                 thread = getOptimalThread();
 260                 thread->pushBlock(blockpos);
 261         }
 262
 263         thread->signal();
 264
 265         return true;
 266 }
 267
 268
 269 //
 270 // Mapgen-related helper functions
 271 //
 272
 273
 274 // TODO(hmmmm): Move this to ServerMap
 275 v3s16 EmergeManager::getContainingChunk(v3s16 blockpos)
 276 {
 277         return getContainingChunk(blockpos, mgparams->chunksize);
 278 }
 279
 280 // TODO(hmmmm): Move this to ServerMap
 281 v3s16 EmergeManager::getContainingChunk(v3s16 blockpos, s16 chunksize)
 282 {
 283         s16 coff = -chunksize / 2;
 284         v3s16 chunk_offset(coff, coff, coff);
 285
 286         return getContainerPos(blockpos - chunk_offset, chunksize)
 287                 * chunksize + chunk_offset;
 288 }
 289
 290
 291 int EmergeManager::getSpawnLevelAtPoint(v2s16 p)
 292 {
 293         if (m_mapgens.size() == 0 || !m_mapgens[0]) {
 294                 errorstream << "EmergeManager: getSpawnLevelAtPoint() called"
 295                         " before mapgen init" << std::endl;
 296                 return 0;
 297         }
 298
 299         return m_mapgens[0]->getSpawnLevelAtPoint(p);
 300 }
 301
 302
 303 int EmergeManager::getGroundLevelAtPoint(v2s16 p)
 304 {
 305         if (m_mapgens.size() == 0 || !m_mapgens[0]) {
 306                 errorstream << "EmergeManager: getGroundLevelAtPoint() called"
 307                         " before mapgen init" << std::endl;
 308                 return 0;
 309         }
 310
 311         return m_mapgens[0]->getGroundLevelAtPoint(p);
 312 }
 313
 314 // TODO(hmmmm): Move this to ServerMap
 315 bool EmergeManager::isBlockUnderground(v3s16 blockpos)
 316 {
 317 #if 0
 318         v2s16 p = v2s16((blockpos.X * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2,
 319                                         (blockpos.Y * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2);
 320         int ground_level = getGroundLevelAtPoint(p);
 321         return blockpos.Y * (MAP_BLOCKSIZE + 1) <= min(water_level, ground_level);
 322 #endif
 323
 324         // Use a simple heuristic; the above method is wildly inaccurate anyway.
 325         return blockpos.Y * (MAP_BLOCKSIZE + 1) <= mgparams->water_level;
 326 }
 327
 328 bool EmergeManager::pushBlockEmergeData(
 329         v3s16 pos,
 330         u16 peer_requested,
 331         u16 flags,
 332         EmergeCompletionCallback callback,
 333         void *callback_param,
 334         bool *entry_already_exists)
 335 {
 336         u16 &count_peer = m_peer_queue_count[peer_requested];
 337
 338         if ((flags & BLOCK_EMERGE_FORCE_QUEUE) == 0) {
 339                 if (m_blocks_enqueued.size() >= m_qlimit_total)
 340                         return false;
 341
 342                 if (peer_requested != PEER_ID_INEXISTENT) {
 343                         u16 qlimit_peer = (flags & BLOCK_EMERGE_ALLOW_GEN) ?
 344                                 m_qlimit_generate : m_qlimit_diskonly;
 345                         if (count_peer >= qlimit_peer)
 346                                 return false;
 347                 }
 348         }
 349
 350         std::pair<std::map<v3s16, BlockEmergeData>::iterator, bool> findres;
 351         findres = m_blocks_enqueued.insert(std::make_pair(pos, BlockEmergeData()));
 352
 353         BlockEmergeData &bedata = findres.first->second;
 354         *entry_already_exists   = !findres.second;
 355
 356         if (callback)
 357                 bedata.callbacks.push_back(std::make_pair(callback, callback_param));
 358
 359         if (*entry_already_exists) {
 360                 bedata.flags |= flags;
 361         } else {
 362                 bedata.flags = flags;
 363                 bedata.peer_requested = peer_requested;
 364
 365                 count_peer++;
 366         }
 367
 368         return true;
 369 }
 370
 371
 372 bool EmergeManager::popBlockEmergeData(v3s16 pos, BlockEmergeData *bedata)
 373 {
 374         std::map<v3s16, BlockEmergeData>::iterator it;
 375         UNORDERED_MAP<u16, u16>::iterator it2;
 376
 377         it = m_blocks_enqueued.find(pos);
 378         if (it == m_blocks_enqueued.end())
 379                 return false;
 380
 381         *bedata = it->second;
 382
 383         it2 = m_peer_queue_count.find(bedata->peer_requested);
 384         if (it2 == m_peer_queue_count.end())
 385                 return false;
 386
 387         u16 &count_peer = it2->second;
 388         assert(count_peer != 0);
 389         count_peer--;
 390
 391         m_blocks_enqueued.erase(it);
 392
 393         return true;
 394 }
 395
 396
 397 EmergeThread *EmergeManager::getOptimalThread()
 398 {
 399         size_t nthreads = m_threads.size();
 400
 401         FATAL_ERROR_IF(nthreads == 0, "No emerge threads!");
 402
 403         size_t index = 0;
 404         size_t nitems_lowest = m_threads[0]->m_block_queue.size();
 405
 406         for (size_t i = 1; i < nthreads; i++) {
 407                 size_t nitems = m_threads[i]->m_block_queue.size();
 408                 if (nitems < nitems_lowest) {
 409                         index = i;
 410                         nitems_lowest = nitems;
 411                 }
 412         }
 413
 414         return m_threads[index];
 415 }
 416
 417
 418 ////
 419 //// EmergeThread
 420 ////
 421
 422 EmergeThread::EmergeThread(Server *server, int ethreadid) :
 423         enable_mapgen_debug_info(false),
 424         id(ethreadid),
 425         m_server(server),
 426         m_map(NULL),
 427         m_emerge(NULL),
 428         m_mapgen(NULL)
 429 {
 430         m_name = "Emerge-" + itos(ethreadid);
 431 }
 432
 433
 434 EmergeThread::~EmergeThread()
 435 {
 436         //cancelPendingItems();
 437 }
 438
 439
 440 void EmergeThread::signal()
 441 {
 442         m_queue_event.signal();
 443 }
 444
 445
 446 bool EmergeThread::pushBlock(v3s16 pos)
 447 {
 448         m_block_queue.push(pos);
 449         return true;
 450 }
 451
 452
 453 void EmergeThread::cancelPendingItems()
 454 {
 455         MutexAutoLock queuelock(m_emerge->m_queue_mutex);
 456
 457         while (!m_block_queue.empty()) {
 458                 BlockEmergeData bedata;
 459                 v3s16 pos;
 460
 461                 pos = m_block_queue.front();
 462                 m_block_queue.pop();
 463
 464                 m_emerge->popBlockEmergeData(pos, &bedata);
 465
 466                 runCompletionCallbacks(pos, EMERGE_CANCELLED, bedata.callbacks);
 467         }
 468 }
 469
 470
 471 void EmergeThread::runCompletionCallbacks(
 472         v3s16 pos,
 473         EmergeAction action,
 474         const EmergeCallbackList &callbacks)
 475 {
 476         for (size_t i = 0; i != callbacks.size(); i++) {
 477                 EmergeCompletionCallback callback;
 478                 void *param;
 479
 480                 callback = callbacks[i].first;
 481                 param    = callbacks[i].second;
 482
 483                 callback(pos, action, param);
 484         }
 485 }
 486
 487
 488 bool EmergeThread::popBlockEmerge(v3s16 *pos, BlockEmergeData *bedata)
 489 {
 490         MutexAutoLock queuelock(m_emerge->m_queue_mutex);
 491
 492         if (m_block_queue.empty())
 493                 return false;
 494
 495         *pos = m_block_queue.front();
 496         m_block_queue.pop();
 497
 498         m_emerge->popBlockEmergeData(*pos, bedata);
 499
 500         return true;
 501 }
 502
 503
 504 EmergeAction EmergeThread::getBlockOrStartGen(
 505         v3s16 pos, bool allow_gen, MapBlock **block, BlockMakeData *bmdata)
 506 {
 507         MutexAutoLock envlock(m_server->m_env_mutex);
 508
 509         // 1). Attempt to fetch block from memory
 510         *block = m_map->getBlockNoCreateNoEx(pos);
 511         if (*block && !(*block)->isDummy()) {
 512                 if ((*block)->isGenerated())
 513                         return EMERGE_FROM_MEMORY;
 514         } else {
 515                 // 2). Attempt to load block from disk if it was not in the memory
 516                 *block = m_map->loadBlock(pos);
 517                 if (*block && (*block)->isGenerated())
 518                         return EMERGE_FROM_DISK;
 519         }
 520
 521         // 3). Attempt to start generation
 522         if (allow_gen && m_map->initBlockMake(pos, bmdata))
 523                 return EMERGE_GENERATED;
 524
 525         // All attempts failed; cancel this block emerge
 526         return EMERGE_CANCELLED;
 527 }
 528
 529
 530 MapBlock *EmergeThread::finishGen(v3s16 pos, BlockMakeData *bmdata,
 531         std::map<v3s16, MapBlock *> *modified_blocks)
 532 {
 533         MutexAutoLock envlock(m_server->m_env_mutex);
 534         ScopeProfiler sp(g_profiler,
 535                 "EmergeThread: after Mapgen::makeChunk", SPT_AVG);
 536
 537         /*
 538                 Perform post-processing on blocks (invalidate lighting, queue liquid
 539                 transforms, etc.) to finish block make
 540         */
 541         m_map->finishBlockMake(bmdata, modified_blocks);
 542
 543         MapBlock *block = m_map->getBlockNoCreateNoEx(pos);
 544         if (!block) {
 545                 errorstream << "EmergeThread::finishGen: Couldn't grab block we "
 546                         "just generated: " << PP(pos) << std::endl;
 547                 return NULL;
 548         }
 549
 550         v3s16 minp = bmdata->blockpos_min * MAP_BLOCKSIZE;
 551         v3s16 maxp = bmdata->blockpos_max * MAP_BLOCKSIZE +
 552                                  v3s16(1,1,1) * (MAP_BLOCKSIZE - 1);
 553
 554         // Ignore map edit events, they will not need to be sent
 555         // to anybody because the block hasn't been sent to anybody
 556         MapEditEventAreaIgnorer ign(
 557                 &m_server->m_ignore_map_edit_events_area,
 558                 VoxelArea(minp, maxp));
 559
 560         /*
 561                 Run Lua on_generated callbacks
 562         */
 563         try {
 564                 m_server->getScriptIface()->environment_OnGenerated(
 565                         minp, maxp, m_mapgen->blockseed);
 566         } catch (LuaError &e) {
 567                 m_server->setAsyncFatalError("Lua: " + std::string(e.what()));
 568         }
 569
 570         EMERGE_DBG_OUT("ended up with: " << analyze_block(block));
 571
 572         /*
 573                 Activate the block
 574         */
 575         m_server->m_env->activateBlock(block, 0);
 576
 577         return block;
 578 }
 579
 580
 581 void *EmergeThread::run()
 582 {
 583         DSTACK(FUNCTION_NAME);
 584         BEGIN_DEBUG_EXCEPTION_HANDLER
 585
 586         v3s16 pos;
 587
 588         m_map    = (ServerMap *)&(m_server->m_env->getMap());
 589         m_emerge = m_server->m_emerge;
 590         m_mapgen = m_emerge->m_mapgens[id];
 591         enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info;
 592
 593         try {
 594         while (!stopRequested()) {
 595                 std::map<v3s16, MapBlock *> modified_blocks;
 596                 BlockEmergeData bedata;
 597                 BlockMakeData bmdata;
 598                 EmergeAction action;
 599                 MapBlock *block;
 600
 601                 if (!popBlockEmerge(&pos, &bedata)) {
 602                         m_queue_event.wait();
 603                         continue;
 604                 }
 605
 606                 if (blockpos_over_limit(pos))
 607                         continue;
 608
 609                 bool allow_gen = bedata.flags & BLOCK_EMERGE_ALLOW_GEN;
 610                 EMERGE_DBG_OUT("pos=" PP(pos) " allow_gen=" << allow_gen);
 611
 612                 action = getBlockOrStartGen(pos, allow_gen, &block, &bmdata);
 613                 if (action == EMERGE_GENERATED) {
 614                         {
 615                                 ScopeProfiler sp(g_profiler,
 616                                         "EmergeThread: Mapgen::makeChunk", SPT_AVG);
 617                                 TimeTaker t("mapgen::make_block()");
 618
 619                                 m_mapgen->makeChunk(&bmdata);
 620
 621                                 if (enable_mapgen_debug_info == false)
 622                                         t.stop(true); // Hide output
 623                         }
 624
 625                         block = finishGen(pos, &bmdata, &modified_blocks);
 626                 }
 627
 628                 runCompletionCallbacks(pos, action, bedata.callbacks);
 629
 630                 if (block)
 631                         modified_blocks[pos] = block;
 632
 633                 if (modified_blocks.size() > 0)
 634                         m_server->SetBlocksNotSent(modified_blocks);
 635         }
 636         } catch (VersionMismatchException &e) {
 637                 std::ostringstream err;
 638                 err << "World data version mismatch in MapBlock " << PP(pos) << std::endl
 639                         << "----" << std::endl
 640                         << "\"" << e.what() << "\"" << std::endl
 641                         << "See debug.txt." << std::endl
 642                         << "World probably saved by a newer version of " PROJECT_NAME_C "."
 643                         << std::endl;
 644                 m_server->setAsyncFatalError(err.str());
 645         } catch (SerializationError &e) {
 646                 std::ostringstream err;
 647                 err << "Invalid data in MapBlock " << PP(pos) << std::endl
 648                         << "----" << std::endl
 649                         << "\"" << e.what() << "\"" << std::endl
 650                         << "See debug.txt." << std::endl
 651                         << "You can ignore this using [ignore_world_load_errors = true]."
 652                         << std::endl;
 653                 m_server->setAsyncFatalError(err.str());
 654         }
 655
 656         END_DEBUG_EXCEPTION_HANDLER
 657         return NULL;
 658 }