m_banfilepath(banfilepath),
m_modified(false)
{
- m_mutex.Init();
try{
load();
}
MeshUpdateQueue::MeshUpdateQueue()
{
- m_mutex.Init();
}
MeshUpdateQueue::~MeshUpdateQueue()
core::list<v3s16> deleted_blocks;
- float delete_unused_sectors_timeout =
+ float delete_unused_sectors_timeout =
g_settings->getFloat("client_delete_unused_sectors_timeout");
// Delete sector blocks
u32 index = 8 + MapNode::serializedLength(ser_version);
if ((datasize >= index+1) && data[index]){
remove_metadata = false;
- }
+ }
addNode(p, n, remove_metadata);
}
m_client_event_queue.push_back(event);
}
else if(command == TOCLIENT_HUDCHANGE)
- {
+ {
std::string sdata;
v2f v2fdata;
u32 intdata = 0;
m_client_event_queue.push_back(event);
}
else if(command == TOCLIENT_HUD_SET_FLAGS)
- {
+ {
std::string datastring((char *)&data[2], datasize - 2);
std::istringstream is(datastring, std::ios_base::binary);
Send(0, data, true);
}
-void Client::sendInventoryFields(const std::string &formname,
+void Client::sendInventoryFields(const std::string &formname,
const std::map<std::string, std::string> &fields)
{
std::ostringstream os(std::ios_base::binary);
writeV3S32(&data[2], position);
writeV3S32(&data[2+12], speed);
writeS32(&data[2+12+12], pitch);
- writeS32(&data[2+12+12+4], yaw);
+ writeS32(&data[2+12+12+4], yaw);
writeU32(&data[2+12+12+4+4], keyPressed);
// Send as unreliable
Send(0, data, false);
m_camera_direction(0,0,1),
m_camera_fov(M_PI)
{
- m_camera_mutex.Init();
- assert(m_camera_mutex.IsInitialized());
-
m_box = core::aabbox3d<f32>(-BS*1000000,-BS*1000000,-BS*1000000,
BS*1000000,BS*1000000,BS*1000000);
}
void debug_stacks_init()
{
- g_debug_stacks_mutex.Init();
}
void debug_stacks_print_to(std::ostream &os)
#include "server.h"
#include <iostream>
#include <queue>
+#include "jthread/jevent.h"
#include "map.h"
#include "environment.h"
#include "util/container.h"
mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
- queuemutex.Init();
int nthreads;
if (g_settings->get("num_emerge_threads").empty()) {
}
-////////////////////////////// Emerge Thread //////////////////////////////////
+////////////////////////////// Emerge Thread //////////////////////////////////
bool EmergeThread::popBlockEmerge(v3s16 *pos, u8 *flags) {
std::map<v3s16, BlockEmergeData *>::iterator iter;
*pos = p;
iter = emerge->blocks_enqueued.find(p);
- if (iter == emerge->blocks_enqueued.end())
+ if (iter == emerge->blocks_enqueued.end())
return false; //uh oh, queue and map out of sync!!
BlockEmergeData *bedata = iter->second;
}
-bool EmergeThread::getBlockOrStartGen(v3s16 p, MapBlock **b,
+bool EmergeThread::getBlockOrStartGen(v3s16 p, MapBlock **b,
BlockMakeData *data, bool allow_gen) {
v2s16 p2d(p.X, p.Z);
//envlock: usually takes <=1ms, sometimes 90ms or ~400ms to acquire
- JMutexAutoLock envlock(m_server->m_env_mutex);
+ JMutexAutoLock envlock(m_server->m_env_mutex);
// Load sector if it isn't loaded
if (map->getSectorNoGenerateNoEx(p2d) == NULL)
{
//envlock: usually 0ms, but can take either 30 or 400ms to acquire
- JMutexAutoLock envlock(m_server->m_env_mutex);
+ JMutexAutoLock envlock(m_server->m_env_mutex);
ScopeProfiler sp(g_profiler, "EmergeThread: after "
"Mapgen::makeChunk (envlock)", SPT_AVG);
// Ignore map edit events, they will not need to be sent
// to anybody because the block hasn't been sent to anybody
- MapEditEventAreaIgnorer
+ MapEditEventAreaIgnorer
ign(&m_server->m_ignore_map_edit_events_area,
VoxelArea(minp, maxp));
{ // takes about 90ms with -O1 on an e3-1230v2
${CMAKE_CURRENT_SOURCE_DIR}/pthread/jmutex.cpp
${CMAKE_CURRENT_SOURCE_DIR}/pthread/jthread.cpp
${CMAKE_CURRENT_SOURCE_DIR}/pthread/jsemaphore.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/pthread/jevent.cpp
PARENT_SCOPE)
else( UNIX )
set(JTHREAD_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/win32/jmutex.cpp
${CMAKE_CURRENT_SOURCE_DIR}/win32/jthread.cpp
${CMAKE_CURRENT_SOURCE_DIR}/win32/jsemaphore.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/win32/jevent.cpp
PARENT_SCOPE)
endif( UNIX )
--- /dev/null
+/*
+
+ This file is a part of the JThread package, which contains some object-
+ oriented thread wrappers for different thread implementations.
+
+ Copyright (c) 2000-2006 Jori Liesenborgs (jori.liesenborgs@gmail.com)
+
+ Permission is hereby granted, free of charge, to any person obtaining a
+ copy of this software and associated documentation files (the "Software"),
+ to deal in the Software without restriction, including without limitation
+ the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ and/or sell copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS IN THE SOFTWARE.
+
+*/
+
+#ifndef JEVENT_H_
+#define JEVENT_H_
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <semaphore.h>
+#endif
+
+
+class Event {
+#ifdef _WIN32
+ HANDLE hEvent;
+#else
+ sem_t sem;
+#endif
+
+public:
+ Event();
+ ~Event();
+ void wait();
+ void signal();
+};
+
+#endif /* JEVENT_H_ */
public:
JMutex();
~JMutex();
- int Init();
int Lock();
int Unlock();
- bool IsInitialized() { return initialized; }
private:
#if (defined(WIN32) || defined(_WIN32_WCE))
return false;
}
#endif // WIN32
- bool initialized;
};
-#ifdef _WIN32
-
-class Event {
- HANDLE hEvent;
-
-public:
- Event() {
- hEvent = CreateEvent(NULL, 0, 0, NULL);
- }
-
- ~Event() {
- CloseHandle(hEvent);
- }
-
- void wait() {
- WaitForSingleObject(hEvent, INFINITE);
- }
-
- void signal() {
- SetEvent(hEvent);
- }
-};
-
-#else
-
-#include <semaphore.h>
-
-class Event {
- sem_t sem;
-
-public:
- Event() {
- sem_init(&sem, 0, 0);
- }
-
- ~Event() {
- sem_destroy(&sem);
- }
-
- void wait() {
- sem_wait(&sem);
- }
-
- void signal() {
- sem_post(&sem);
- }
-};
-
-#endif
-
#endif // JMUTEX_H
JMutex runningmutex;
JMutex continuemutex,continuemutex2;
- bool mutexinit;
};
#endif // JTHREAD_H
--- /dev/null
+/*
+
+ This file is a part of the JThread package, which contains some object-
+ oriented thread wrappers for different thread implementations.
+
+ Copyright (c) 2000-2006 Jori Liesenborgs (jori.liesenborgs@gmail.com)
+
+ Permission is hereby granted, free of charge, to any person obtaining a
+ copy of this software and associated documentation files (the "Software"),
+ to deal in the Software without restriction, including without limitation
+ the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ and/or sell copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS IN THE SOFTWARE.
+
+*/
+#include <assert.h>
+#include "jthread/jevent.h"
+
+Event::Event() {
+ assert(sem_init(&sem, 0, 0) == 0);
+}
+
+Event::~Event() {
+ assert(sem_destroy(&sem) == 0);
+}
+
+void Event::wait() {
+ assert(sem_wait(&sem) == 0);
+}
+
+void Event::signal() {
+ assert(sem_post(&sem) == 0);
+}
DEALINGS IN THE SOFTWARE.
*/
-
+#include <assert.h>
#include "jthread/jmutex.h"
JMutex::JMutex()
{
- pthread_mutex_init(&mutex,NULL);
- initialized = true;
+ assert(pthread_mutex_init(&mutex,NULL) == 0);
}
JMutex::~JMutex()
{
- if (initialized)
- pthread_mutex_destroy(&mutex);
-}
-
-int JMutex::Init()
-{
- return 0;
+ assert(pthread_mutex_destroy(&mutex) == 0);
}
int JMutex::Lock()
{
- if (!initialized)
- return ERR_JMUTEX_NOTINIT;
-
- pthread_mutex_lock(&mutex);
+ assert(pthread_mutex_lock(&mutex) == 0);
return 0;
}
int JMutex::Unlock()
{
- if (!initialized)
- return ERR_JMUTEX_NOTINIT;
-
- pthread_mutex_unlock(&mutex);
+ assert(pthread_mutex_unlock(&mutex) == 0);
return 0;
}
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
+#include <assert.h>
#include "jthread/jsemaphore.h"
JSemaphore::JSemaphore() {
- sem_init(&m_semaphore,0,0);
+ assert(sem_init(&m_semaphore,0,0) == 0);
}
JSemaphore::~JSemaphore() {
- sem_destroy(&m_semaphore);
+ assert(sem_destroy(&m_semaphore) == 0);
}
JSemaphore::JSemaphore(int initval) {
- sem_init(&m_semaphore,0,initval);
+ assert(sem_init(&m_semaphore,0,initval) == 0);
}
void JSemaphore::Post() {
- sem_post(&m_semaphore);
+ assert(sem_post(&m_semaphore) == 0);
}
void JSemaphore::Wait() {
- sem_wait(&m_semaphore);
+ assert(sem_wait(&m_semaphore) == 0);
}
int JSemaphore::GetValue() {
JThread::JThread()
{
retval = NULL;
- mutexinit = false;
requeststop = false;
running = false;
}
{
int status;
- if (!mutexinit)
- {
- if (!runningmutex.IsInitialized())
- {
- if (runningmutex.Init() < 0)
- return ERR_JTHREAD_CANTINITMUTEX;
- }
- if (!continuemutex.IsInitialized())
- {
- if (continuemutex.Init() < 0)
- return ERR_JTHREAD_CANTINITMUTEX;
- }
- if (!continuemutex2.IsInitialized())
- {
- if (continuemutex2.Init() < 0)
- return ERR_JTHREAD_CANTINITMUTEX;
- }
- mutexinit = true;
- }
-
runningmutex.Lock();
if (running)
{
--- /dev/null
+/*
+
+ This file is a part of the JThread package, which contains some object-
+ oriented thread wrappers for different thread implementations.
+
+ Copyright (c) 2000-2006 Jori Liesenborgs (jori.liesenborgs@gmail.com)
+
+ Permission is hereby granted, free of charge, to any person obtaining a
+ copy of this software and associated documentation files (the "Software"),
+ to deal in the Software without restriction, including without limitation
+ the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ and/or sell copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS IN THE SOFTWARE.
+
+*/
+#include "jthread/jevent.h"
+
+Event::Event() {
+ hEvent = CreateEvent(NULL, 0, 0, NULL);
+}
+
+Event::~Event() {
+ CloseHandle(hEvent);
+}
+
+void Event::wait() {
+ WaitForSingleObject(hEvent, INFINITE);
+}
+
+void Event::signal() {
+ SetEvent(hEvent);
+}
DEALINGS IN THE SOFTWARE.
*/
-
+#include <assert.h>
#include "jthread/jmutex.h"
JMutex::JMutex()
InitializeCriticalSection(&mutex);
#else
mutex = CreateMutex(NULL,FALSE,NULL);
- if (mutex == NULL)
- return ERR_JMUTEX_CANTCREATEMUTEX;
+ assert(mutex != NULL);
#endif // JMUTEX_CRITICALSECTION
- initialized = true;
}
JMutex::~JMutex()
{
- if (initialized)
#ifdef JMUTEX_CRITICALSECTION
- DeleteCriticalSection(&mutex);
+ DeleteCriticalSection(&mutex);
#else
- CloseHandle(mutex);
+ CloseHandle(mutex);
#endif // JMUTEX_CRITICALSECTION
}
-int JMutex::Init()
-{
- return 0;
-}
-
int JMutex::Lock()
{
- if (!initialized)
- return ERR_JMUTEX_NOTINIT;
#ifdef JMUTEX_CRITICALSECTION
EnterCriticalSection(&mutex);
#else
int JMutex::Unlock()
{
- if (!initialized)
- return ERR_JMUTEX_NOTINIT;
#ifdef JMUTEX_CRITICALSECTION
LeaveCriticalSection(&mutex);
#else
JThread::JThread()
{
retval = NULL;
- mutexinit = false;
requeststop = false;
running = false;
}
int JThread::Start()
{
- if (!mutexinit)
- {
- if (!runningmutex.IsInitialized())
- {
- if (runningmutex.Init() < 0)
- return ERR_JTHREAD_CANTINITMUTEX;
- }
- if (!continuemutex.IsInitialized())
- {
- if (continuemutex.Init() < 0)
- return ERR_JTHREAD_CANTINITMUTEX;
- }
- if (!continuemutex2.IsInitialized())
- {
- if (continuemutex2.Init() < 0)
- return ERR_JTHREAD_CANTINITMUTEX;
- } mutexinit = true;
- }
-
runningmutex.Lock();
if (running)
{
#endif
#if USE_CURL
-#include "curl.h"
+#include "curl/curl.h"
#endif
/*
TimeTaker timer("Testing mutex speed");
JMutex m;
- m.Init();
u32 n = 0;
u32 i = 0;
do{
m_gamedef(gamedef),
m_sector_cache(NULL)
{
- /*m_sector_mutex.Init();
- assert(m_sector_mutex.IsInitialized());*/
}
Map::~Map()
v3s16 p0 = m_transforming_liquid.pop_front();
u16 total_level = 0;
// surrounding flowing liquid nodes
- NodeNeighbor neighbors[7];
+ NodeNeighbor neighbors[7];
// current level of every block
s8 liquid_levels[7] = {-1, -1, -1, -1, -1, -1, -1};
// target levels
liquid_levels[D_BOTTOM] == LIQUID_LEVEL_SOURCE &&
total_level >= LIQUID_LEVEL_SOURCE * can_liquid_same_level-
(can_liquid_same_level - relax) &&
- can_liquid_same_level >= relax + 1) {
- total_level = LIQUID_LEVEL_SOURCE * can_liquid_same_level;
+ can_liquid_same_level >= relax + 1) {
+ total_level = LIQUID_LEVEL_SOURCE * can_liquid_same_level;
}
// prevent lakes in air above unloaded blocks
}
// calculate self level 5 blocks
- u8 want_level =
+ u8 want_level =
total_level >= LIQUID_LEVEL_SOURCE * can_liquid_same_level
- ? LIQUID_LEVEL_SOURCE
+ ? LIQUID_LEVEL_SOURCE
: total_level / can_liquid_same_level;
total_level -= want_level * can_liquid_same_level;
/*
if (total_level > 0) //|| flowed != volume)
- infostream <<" AFTER level=" << (int)total_level
+ infostream <<" AFTER level=" << (int)total_level
//<< " flowed="<<flowed<< " volume=" << volume
<< " wantsame="<<(int)want_level<< " top="
<< (int)liquid_levels_want[D_TOP]<< " topwas="
//u8 changed = 0;
for (u16 i = 0; i < 7; i++) {
- if (liquid_levels_want[i] < 0 || !neighbors[i].l)
+ if (liquid_levels_want[i] < 0 || !neighbors[i].l)
continue;
MapNode & n0 = neighbors[i].n;
p0 = neighbors[i].p;
*/
/*
if (
- new_node_content == n0.getContent()
+ new_node_content == n0.getContent()
&& (nodemgr->get(n0.getContent()).liquid_type != LIQUID_FLOWING ||
(n0.getLevel(nodemgr) == (u8)new_node_level
//&& ((n0.param2 & LIQUID_FLOW_DOWN_MASK) ==
reallocate();
#ifndef SERVER
- //mesh_mutex.Init();
mesh = NULL;
#endif
}
public:
Profiler()
{
- m_mutex.Init();
}
void add(const std::string &name, float value)
{
if(!g_mutex){
g_mutex = new JMutex();
- g_mutex->Init();
}
}
ScriptApiBase::ScriptApiBase()
{
- m_luastackmutex.Init();
-
#ifdef SCRIPTAPI_LOCK_DEBUG
m_locked = false;
#endif
m_initDone(false),
m_JobIdCounter(0)
{
- assert(m_JobQueueMutex.Init() == 0);
- assert(m_ResultQueueMutex.Init() == 0);
}
/******************************************************************************/
m_emergethread_trigger_timer = 0.0;
m_savemap_timer = 0.0;
- m_env_mutex.Init();
- m_con_mutex.Init();
- m_step_dtime_mutex.Init();
m_step_dtime = 0.0;
if(path_world == "")
m_mods = modconf.getMods();
std::vector<ModSpec> unsatisfied_mods = modconf.getUnsatisfiedMods();
// complain about mods with unsatisfied dependencies
- if(!modconf.isConsistent())
+ if(!modconf.isConsistent())
{
for(std::vector<ModSpec>::iterator it = unsatisfied_mods.begin();
it != unsatisfied_mods.end(); ++it)
worldmt_settings.readConfigFile(worldmt.c_str());
std::vector<std::string> names = worldmt_settings.getNames();
std::set<std::string> load_mod_names;
- for(std::vector<std::string>::iterator it = names.begin();
+ for(std::vector<std::string>::iterator it = names.begin();
it != names.end(); ++it)
- {
- std::string name = *it;
+ {
+ std::string name = *it;
if(name.compare(0,9,"load_mod_")==0 && worldmt_settings.getBool(name))
load_mod_names.insert(name.substr(9));
}
it != unsatisfied_mods.end(); ++it)
load_mod_names.erase((*it).name);
if(!load_mod_names.empty())
- {
+ {
errorstream << "The following mods could not be found:";
for(std::set<std::string>::iterator it = load_mod_names.begin();
it != load_mod_names.end(); ++it)
public:
Settings()
{
- m_mutex.Init();
}
void writeLines(std::ostream &os)
}
}
- // return all keys used
+ // return all keys used
std::vector<std::string> getNames(){
std::vector<std::string> names;
for(std::map<std::string, std::string>::iterator
{
names.push_back(i->first);
}
- return names;
+ return names;
}
// remove a setting
m_shader_callback = new ShaderCallback(this, "default");
- m_shaderinfo_cache_mutex.Init();
-
m_main_thread = get_current_thread_id();
// Add a dummy ShaderInfo as the first index, named ""
{
assert(m_device);
- m_textureinfo_cache_mutex.Init();
-
m_main_thread = get_current_thread_id();
// Add a NULL TextureInfo as the first index, named ""
public:
MutexedMap()
{
- m_mutex.Init();
- assert(m_mutex.IsInitialized());
}
void set(const Key &name, const Value &value)
public:
MutexedIdGenerator()
{
- m_mutex.Init();
- assert(m_mutex.IsInitialized());
}
// Returns true if found
public:
MutexedQueue()
{
- m_mutex.Init();
}
bool empty()
{
MutexedVariable(T value):
m_value(value)
{
- m_mutex.Init();
}
T get()
JThread(),
run(true)
{
- run_mutex.Init();
}
virtual ~SimpleThread()
projects / zefram / minetest / minetest_engine.git / commitdiff