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