#include "server.h"
#include <iostream>
#include <queue>
-#include "jthread/jevent.h"
+#include "threading/event.h"
#include "map.h"
#include "environment.h"
#include "util/container.h"
#include "util/thread.h"
-#include "main.h"
#include "constants.h"
#include "voxel.h"
#include "config.h"
{"singlenode", new MapgenFactorySinglenode},
};
-class EmergeThread : public JThread
+class EmergeThread : public Thread
{
public:
Server *m_server;
std::queue<v3s16> blockqueue;
EmergeThread(Server *server, int ethreadid):
- JThread(),
m_server(server),
map(NULL),
emerge(NULL),
enable_mapgen_debug_info(false),
id(ethreadid)
{
+ name = "Emerge-" + itos(id);
}
- void *Thread();
+ void *run();
bool popBlockEmerge(v3s16 *pos, u8 *flags);
bool getBlockOrStartGen(v3s16 p, MapBlock **b,
BlockMakeData *data, bool allow_generate);
// some other misc thread
s16 nthreads = 0;
if (!g_settings->getS16NoEx("num_emerge_threads", nthreads))
- nthreads = porting::getNumberOfProcessors() - 2;
+ nthreads = Thread::getNumberOfProcessors() - 2;
if (nthreads < 1)
nthreads = 1;
{
for (u32 i = 0; i != emergethread.size(); i++) {
if (threads_active) {
- emergethread[i]->Stop();
+ emergethread[i]->stop();
emergethread[i]->qevent.signal();
- emergethread[i]->Wait();
+ emergethread[i]->wait();
}
delete emergethread[i];
delete mapgen[i];
void EmergeManager::loadMapgenParams()
{
- loadParamsFromSettings(g_settings);
-
- if (g_settings->get("fixed_map_seed").empty()) {
- params.seed = (((u64)(myrand() & 0xffff) << 0)
- | ((u64)(myrand() & 0xffff) << 16)
- | ((u64)(myrand() & 0xffff) << 32)
- | ((u64)(myrand() & 0xffff) << 48));
- }
+ params.load(*g_settings);
}
Mapgen *EmergeManager::getCurrentMapgen()
{
for (u32 i = 0; i != emergethread.size(); i++) {
- if (emergethread[i]->IsSameThread())
+ if (emergethread[i]->isSameThread())
return emergethread[i]->mapgen;
}
return;
for (u32 i = 0; i != emergethread.size(); i++)
- emergethread[i]->Start();
+ emergethread[i]->start();
threads_active = true;
}
// Request thread stop in parallel
for (u32 i = 0; i != emergethread.size(); i++) {
- emergethread[i]->Stop();
+ emergethread[i]->stop();
emergethread[i]->qevent.signal();
}
// Then do the waiting for each
for (u32 i = 0; i != emergethread.size(); i++)
- emergethread[i]->Wait();
+ emergethread[i]->wait();
threads_active = false;
}
flags |= BLOCK_EMERGE_ALLOWGEN;
{
- JMutexAutoLock queuelock(queuemutex);
+ MutexAutoLock queuelock(queuemutex);
count = blocks_enqueued.size();
if (count >= qlimit_total)
MapgenSpecificParams *EmergeManager::createMapgenParams(const std::string &mgname)
{
u32 i;
- for (i = 0; i != ARRLEN(reg_mapgens) && mgname != reg_mapgens[i].name; i++);
+ for (i = 0; i < ARRLEN(reg_mapgens) && mgname != reg_mapgens[i].name; i++);
if (i == ARRLEN(reg_mapgens)) {
- errorstream << "EmergeManager; mapgen " << mgname <<
+ errorstream << "EmergeManager: Mapgen " << mgname <<
" not registered" << std::endl;
return NULL;
}
}
-void EmergeManager::loadParamsFromSettings(Settings *settings)
-{
- std::string seed_str;
- const char *setname = (settings == g_settings) ? "fixed_map_seed" : "seed";
-
- if (settings->getNoEx(setname, seed_str))
- params.seed = read_seed(seed_str.c_str());
-
- settings->getNoEx("mg_name", params.mg_name);
- settings->getS16NoEx("water_level", params.water_level);
- settings->getS16NoEx("chunksize", params.chunksize);
- settings->getFlagStrNoEx("mg_flags", params.flags, flagdesc_mapgen);
- settings->getNoiseParams("mg_biome_np_heat", params.np_biome_heat);
- settings->getNoiseParams("mg_biome_np_humidity", params.np_biome_humidity);
-
- delete params.sparams;
- params.sparams = createMapgenParams(params.mg_name);
- if (params.sparams)
- params.sparams->readParams(settings);
-}
-
-
-void EmergeManager::saveParamsToSettings(Settings *settings)
-{
- settings->set("mg_name", params.mg_name);
- settings->setU64("seed", params.seed);
- settings->setS16("water_level", params.water_level);
- settings->setS16("chunksize", params.chunksize);
- settings->setFlagStr("mg_flags", params.flags, flagdesc_mapgen, (u32)-1);
- settings->setNoiseParams("mg_biome_np_heat", params.np_biome_heat);
- settings->setNoiseParams("mg_biome_np_humidity", params.np_biome_humidity);
-
- if (params.sparams)
- params.sparams->writeParams(settings);
-}
-
-
////////////////////////////// Emerge Thread //////////////////////////////////
bool EmergeThread::popBlockEmerge(v3s16 *pos, u8 *flags)
{
std::map<v3s16, BlockEmergeData *>::iterator iter;
- JMutexAutoLock queuelock(emerge->queuemutex);
+ MutexAutoLock queuelock(emerge->queuemutex);
if (blockqueue.empty())
return false;
{
v2s16 p2d(p.X, p.Z);
//envlock: usually takes <=1ms, sometimes 90ms or ~400ms to acquire
- JMutexAutoLock envlock(m_server->m_env_mutex);
+ MutexAutoLock envlock(m_server->m_env_mutex);
// Load sector if it isn't loaded
if (map->getSectorNoGenerateNoEx(p2d) == NULL)
}
-void *EmergeThread::Thread()
+void *EmergeThread::run()
{
- ThreadStarted();
- log_register_thread("EmergeThread" + itos(id));
DSTACK(__FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
mapgen = emerge->mapgen[id];
enable_mapgen_debug_info = emerge->mapgen_debug_info;
- porting::setThreadName("EmergeThread");
-
- while (!StopRequested())
+ while (!stopRequested())
try {
if (!popBlockEmerge(&p, &flags)) {
qevent.wait();
{
//envlock: usually 0ms, but can take either 30 or 400ms to acquire
- JMutexAutoLock envlock(m_server->m_env_mutex);
+ MutexAutoLock envlock(m_server->m_env_mutex);
ScopeProfiler sp(g_profiler, "EmergeThread: after "
"Mapgen::makeChunk (envlock)", SPT_AVG);
try { // takes about 90ms with -O1 on an e3-1230v2
m_server->getScriptIface()->environment_OnGenerated(
minp, maxp, mapgen->blockseed);
- } catch(LuaError &e) {
- m_server->setAsyncFatalError(e.what());
+ } catch (LuaError &e) {
+ m_server->setAsyncFatalError("Lua: " + std::string(e.what()));
}
EMERGE_DBG_OUT("ended up with: " << analyze_block(block));
}
catch (VersionMismatchException &e) {
std::ostringstream err;
- err << "World data version mismatch in MapBlock "<<PP(last_tried_pos)<<std::endl;
- err << "----"<<std::endl;
- err << "\""<<e.what()<<"\""<<std::endl;
- err << "See debug.txt."<<std::endl;
- err << "World probably saved by a newer version of Minetest."<<std::endl;
+ err << "World data version mismatch in MapBlock " << PP(last_tried_pos) << std::endl
+ << "----" << std::endl
+ << "\"" << e.what() << "\"" << std::endl
+ << "See debug.txt." << std::endl
+ << "World probably saved by a newer version of " PROJECT_NAME_C "."
+ << std::endl;
m_server->setAsyncFatalError(err.str());
}
catch (SerializationError &e) {
std::ostringstream err;
- err << "Invalid data in MapBlock "<<PP(last_tried_pos)<<std::endl;
- err << "----"<<std::endl;
- err << "\""<<e.what()<<"\""<<std::endl;
- err << "See debug.txt."<<std::endl;
- err << "You can ignore this using [ignore_world_load_errors = true]."<<std::endl;
+ err << "Invalid data in MapBlock " << PP(last_tried_pos) << std::endl
+ << "----" << std::endl
+ << "\"" << e.what() << "\"" << std::endl
+ << "See debug.txt." << std::endl
+ << "You can ignore this using [ignore_world_load_errors = true]."
+ << std::endl;
m_server->setAsyncFatalError(err.str());
}
{
- JMutexAutoLock queuelock(emerge->queuemutex);
+ MutexAutoLock queuelock(emerge->queuemutex);
while (!blockqueue.empty())
{
v3s16 p = blockqueue.front();
}
END_DEBUG_EXCEPTION_HANDLER(errorstream)
- log_deregister_thread();
return NULL;
}
projects / dragonfireclient.git / blobdiff