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