Extex101
/
minetest
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Clean up threading 

* Rename everything.
    * Strip J prefix.
    * Change UpperCamelCase functions to lowerCamelCase.
  * Remove global (!) semaphore count mutex on OSX.
  * Remove semaphore count getter (unused, unsafe, depended on internal
    API functions on Windows, and used a hack on OSX).
  * Add `Atomic<type>`.
  * Make `Thread` handle thread names.
  * Add support for C++11 multi-threading.
  * Combine pthread and win32 sources.
  * Remove `ThreadStarted` (unused, unneeded).
  * Move some includes from the headers to the sources.
  * Move all of `Event` into its header (allows inlining with no new includes).
  * Make `Event` use `Semaphore` (except on Windows).
  * Move some porting functions into `Thread`.
  * Integrate logging with `Thread`.
  * Add threading test.
master
ShadowNinja 2015-04-07 06:13:12 -04:00
parent 6a1047d8c1
commit e4bff8be94
77 changed files with 1594 additions and 2046 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
.gitignore vendored
View File

@ -36,45 +36,18 @@ doc/html/
doc/doxygen_*
## Build files
CMakeFiles/*
src/CMakeFiles/*
src/Makefile
src/android_version_githash.h
src/android_version.h
src/cmake_config.h
src/cmake_config_githash.h
src/cmake_install.cmake
src/script/CMakeFiles/*
src/script/common/CMakeFiles/*
src/script/cpp_api/CMakeFiles/*
src/script/lua_api/CMakeFiles/*
src/util/CMakeFiles/*
src/unittest/CMakeFiles/*
src/jthread/CMakeFiles/*
src/jthread/Makefile
src/jthread/cmake_config.h
src/jthread/cmake_install.cmake
src/jthread/libjthread.a
src/json/libjson.a
src/lua/build/
src/lua/CMakeFiles/
src/cguittfont/CMakeFiles/
src/cguittfont/libcguittfont.a
src/cguittfont/cmake_install.cmake
src/cguittfont/Makefile
src/gmp/CMakeFiles/
src/gmp/libgmp.a
src/json/CMakeFiles/
src/json/libjsoncpp.a
src/sqlite/CMakeFiles/*
src/sqlite/libsqlite3.a
src/client/CMakeFiles/
src/network/CMakeFiles/
CMakeFiles
Makefile
!build/android/Makefile
cmake_install.cmake
CMakeCache.txt
CPackConfig.cmake
CPackSourceConfig.cmake
Makefile
cmake_install.cmake
src/android_version.h
src/android_version_githash.h
src/cmake_config.h
src/cmake_config_githash.h
src/lua/build/
locale/
.directory
.kdev4/
@ -82,6 +55,7 @@ locale/
*.kdev4
*.layout
*.o
*.a
## Android build files
build/android/assets

13
build/android/jni/Android.mk
View File

@ -342,17 +342,16 @@ LOCAL_SRC_FILES += \
jni/src/lua/src/lzio.c \
jni/src/lua/src/print.c
# sqlite
# SQLite3
LOCAL_SRC_FILES += deps/sqlite/sqlite3.c
# jthread
# Threading
LOCAL_SRC_FILES += \
jni/src/jthread/pthread/jevent.cpp \
jni/src/jthread/pthread/jmutex.cpp \
jni/src/jthread/pthread/jsemaphore.cpp \
jni/src/jthread/pthread/jthread.cpp
jni/src/threading/Mutex.cpp \
jni/src/threading/Semaphore.cpp \
jni/src/threading/Thread.cpp
# json
# JSONCPP
LOCAL_SRC_FILES += jni/src/json/jsoncpp.cpp
LOCAL_SHARED_LIBRARIES := iconv openal ogg vorbis gmp

2
src/CMakeLists.txt
View File

@ -297,7 +297,7 @@ add_custom_target(GenerateVersion
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
add_subdirectory(jthread)
add_subdirectory(threading)
add_subdirectory(network)
add_subdirectory(script)
add_subdirectory(unittest)

18
src/ban.cpp
View File

@ -19,7 +19,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "ban.h"
#include <fstream>
#include "jthread/jmutexautolock.h"
#include "threading/mutex_auto_lock.h"
#include <sstream>
#include <set>
#include "strfnd.h"
@ -48,7 +48,7 @@ BanManager::~BanManager()
void BanManager::load()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
infostream<<"BanManager: loading from "<<m_banfilepath<<std::endl;
std::ifstream is(m_banfilepath.c_str(), std::ios::binary);
if(is.good() == false)
@ -73,7 +73,7 @@ void BanManager::load()
void BanManager::save()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
infostream << "BanManager: saving to " << m_banfilepath << std::endl;
std::ostringstream ss(std::ios_base::binary);
@ -90,13 +90,13 @@ void BanManager::save()
bool BanManager::isIpBanned(const std::string &ip)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
return m_ips.find(ip) != m_ips.end();
}
std::string BanManager::getBanDescription(const std::string &ip_or_name)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
std::string s = "";
for (StringMap::iterator it = m_ips.begin(); it != m_ips.end(); ++it) {
if (it->first == ip_or_name || it->second == ip_or_name
@ -110,7 +110,7 @@ std::string BanManager::getBanDescription(const std::string &ip_or_name)
std::string BanManager::getBanName(const std::string &ip)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
StringMap::iterator it = m_ips.find(ip);
if (it == m_ips.end())
return "";
@ -119,14 +119,14 @@ std::string BanManager::getBanName(const std::string &ip)
void BanManager::add(const std::string &ip, const std::string &name)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
m_ips[ip] = name;
m_modified = true;
}
void BanManager::remove(const std::string &ip_or_name)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
for (StringMap::iterator it = m_ips.begin(); it != m_ips.end();) {
if ((it->first == ip_or_name) || (it->second == ip_or_name)) {
m_ips.erase(it++);
@ -140,7 +140,7 @@ void BanManager::remove(const std::string &ip_or_name)
bool BanManager::isModified()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
return m_modified;
}

8
src/ban.h
View File

@ -21,9 +21,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#define BAN_HEADER
#include "util/string.h"
#include "jthread/jthread.h"
#include "jthread/jmutex.h"
#include "threading/thread.h"
#include "threading/mutex.h"
#include "exceptions.h"
#include <map>
#include <string>
class BanManager
{
@ -40,7 +42,7 @@ public:
void remove(const std::string &ip_or_name);
bool isModified();
private:
JMutex m_mutex;
Mutex m_mutex;
std::string m_banfilepath;
StringMap m_ips;
bool m_modified;

20
src/client.cpp
View File

@ -21,7 +21,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <algorithm>
#include <sstream>
#include <IFileSystem.h>
#include "jthread/jmutexautolock.h"
#include "threading/mutex_auto_lock.h"
#include "util/auth.h"
#include "util/directiontables.h"
#include "util/pointedthing.h"
@ -82,7 +82,7 @@ MeshUpdateQueue::MeshUpdateQueue()
MeshUpdateQueue::~MeshUpdateQueue()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
for(std::vector<QueuedMeshUpdate*>::iterator
i = m_queue.begin();
@ -102,7 +102,7 @@ void MeshUpdateQueue::addBlock(v3s16 p, MeshMakeData *data, bool ack_block_to_se
assert(data); // pre-condition
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
if(urgent)
m_urgents.insert(p);
@ -141,7 +141,7 @@ void MeshUpdateQueue::addBlock(v3s16 p, MeshMakeData *data, bool ack_block_to_se
// Returns NULL if queue is empty
QueuedMeshUpdate *MeshUpdateQueue::pop()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
bool must_be_urgent = !m_urgents.empty();
for(std::vector<QueuedMeshUpdate*>::iterator
@ -269,7 +269,7 @@ Client::Client(
void Client::Stop()
{
//request all client managed threads to stop
m_mesh_update_thread.Stop();
m_mesh_update_thread.stop();
// Save local server map
if (m_localdb) {
infostream << "Local map saving ended." << std::endl;
@ -280,7 +280,7 @@ void Client::Stop()
bool Client::isShutdown()
{
if (!m_mesh_update_thread.IsRunning()) return true;
if (!m_mesh_update_thread.isRunning()) return true;
return false;
}
@ -289,8 +289,8 @@ Client::~Client()
{
m_con.Disconnect();
m_mesh_update_thread.Stop();
m_mesh_update_thread.Wait();
m_mesh_update_thread.stop();
m_mesh_update_thread.wait();
while (!m_mesh_update_thread.m_queue_out.empty()) {
MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_frontNoEx();
delete r.mesh;
@ -1270,7 +1270,7 @@ void Client::sendPlayerPos()
u16 our_peer_id;
{
//JMutexAutoLock lock(m_con_mutex); //bulk comment-out
//MutexAutoLock lock(m_con_mutex); //bulk comment-out
our_peer_id = m_con.GetPeerID();
}
@ -1794,7 +1794,7 @@ void Client::afterContentReceived(IrrlichtDevice *device)
// Start mesh update thread after setting up content definitions
infostream<<"- Starting mesh update thread"<<std::endl;
m_mesh_update_thread.Start();
m_mesh_update_thread.start();
m_state = LC_Ready;
sendReady();

13
src/client.h
View File

@ -23,7 +23,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "network/connection.h"
#include "environment.h"
#include "irrlichttypes_extrabloated.h"
#include "jthread/jmutex.h"
#include "threading/mutex.h"
#include <ostream>
#include <map>
#include <set>
@ -89,14 +89,14 @@ public:
u32 size()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
return m_queue.size();
}
private:
std::vector<QueuedMeshUpdate*> m_queue;
std::set<v3s16> m_urgents;
JMutex m_mutex;
Mutex m_mutex;
};
struct MeshUpdateResult
@ -119,19 +119,14 @@ private:
MeshUpdateQueue m_queue_in;
protected:
const char *getName()
{ return "MeshUpdateThread"; }
virtual void doUpdate();
public:
MeshUpdateThread()
{
}
MeshUpdateThread() : UpdateThread("Mesh") {}
void enqueueUpdate(v3s16 p, MeshMakeData *data,
bool ack_block_to_server, bool urgent);
MutexedQueue<MeshUpdateResult> m_queue_out;
v3s16 m_camera_offset;

6
src/client/clientlauncher.cpp
View File

@ -651,14 +651,14 @@ void ClientLauncher::speed_tests()
infostream << "Around 5000/ms should do well here." << std::endl;
TimeTaker timer("Testing mutex speed");
JMutex m;
Mutex m;
u32 n = 0;
u32 i = 0;
do {
n += 10000;
for (; i < n; i++) {
m.Lock();
m.Unlock();
m.lock();
m.unlock();
}
}
// Do at least 10ms

14
src/client/tile.cpp
View File

@ -414,7 +414,7 @@ private:
// Maps a texture name to an index in the former.
std::map<std::string, u32> m_name_to_id;
// The two former containers are behind this mutex
JMutex m_textureinfo_cache_mutex;
Mutex m_textureinfo_cache_mutex;
// Queued texture fetches (to be processed by the main thread)
RequestQueue<std::string, u32, u8, u8> m_get_texture_queue;
@ -490,7 +490,7 @@ u32 TextureSource::getTextureId(const std::string &name)
/*
See if texture already exists
*/
JMutexAutoLock lock(m_textureinfo_cache_mutex);
MutexAutoLock lock(m_textureinfo_cache_mutex);
std::map<std::string, u32>::iterator n;
n = m_name_to_id.find(name);
if (n != m_name_to_id.end())
@ -593,7 +593,7 @@ u32 TextureSource::generateTexture(const std::string &name)
/*
See if texture already exists
*/
JMutexAutoLock lock(m_textureinfo_cache_mutex);
MutexAutoLock lock(m_textureinfo_cache_mutex);
std::map<std::string, u32>::iterator n;
n = m_name_to_id.find(name);
if (n != m_name_to_id.end()) {
@ -631,7 +631,7 @@ u32 TextureSource::generateTexture(const std::string &name)
Add texture to caches (add NULL textures too)
*/
JMutexAutoLock lock(m_textureinfo_cache_mutex);
MutexAutoLock lock(m_textureinfo_cache_mutex);
u32 id = m_textureinfo_cache.size();
TextureInfo ti(name, tex);
@ -643,7 +643,7 @@ u32 TextureSource::generateTexture(const std::string &name)
std::string TextureSource::getTextureName(u32 id)
{
JMutexAutoLock lock(m_textureinfo_cache_mutex);
MutexAutoLock lock(m_textureinfo_cache_mutex);
if (id >= m_textureinfo_cache.size())
{
@ -658,7 +658,7 @@ std::string TextureSource::getTextureName(u32 id)
video::ITexture* TextureSource::getTexture(u32 id)
{
JMutexAutoLock lock(m_textureinfo_cache_mutex);
MutexAutoLock lock(m_textureinfo_cache_mutex);
if (id >= m_textureinfo_cache.size())
return NULL;
@ -712,7 +712,7 @@ void TextureSource::insertSourceImage(const std::string &name, video::IImage *im
void TextureSource::rebuildImagesAndTextures()
{
JMutexAutoLock lock(m_textureinfo_cache_mutex);
MutexAutoLock lock(m_textureinfo_cache_mutex);
video::IVideoDriver* driver = m_device->getVideoDriver();
sanity_check(driver);

24
src/clientiface.cpp
View File

@ -593,7 +593,7 @@ ClientInterface::~ClientInterface()
Delete clients
*/
{
JMutexAutoLock clientslock(m_clients_mutex);
MutexAutoLock clientslock(m_clients_mutex);
for(std::map<u16, RemoteClient*>::iterator
i = m_clients.begin();
@ -609,7 +609,7 @@ ClientInterface::~ClientInterface()
std::vector<u16> ClientInterface::getClientIDs(ClientState min_state)
{
std::vector<u16> reply;
JMutexAutoLock clientslock(m_clients_mutex);
MutexAutoLock clientslock(m_clients_mutex);
for(std::map<u16, RemoteClient*>::iterator
i = m_clients.begin();
@ -660,7 +660,7 @@ void ClientInterface::UpdatePlayerList()
infostream << "* " << player->getName() << "\t";
{
JMutexAutoLock clientslock(m_clients_mutex);
MutexAutoLock clientslock(m_clients_mutex);
RemoteClient* client = lockedGetClientNoEx(*i);
if(client != NULL)
client->PrintInfo(infostream);
@ -680,7 +680,7 @@ void ClientInterface::send(u16 peer_id, u8 channelnum,
void ClientInterface::sendToAll(u16 channelnum,
NetworkPacket* pkt, bool reliable)
{
JMutexAutoLock clientslock(m_clients_mutex);
MutexAutoLock clientslock(m_clients_mutex);
for(std::map<u16, RemoteClient*>::iterator
i = m_clients.begin();
i != m_clients.end(); ++i) {
@ -694,7 +694,7 @@ void ClientInterface::sendToAll(u16 channelnum,
RemoteClient* ClientInterface::getClientNoEx(u16 peer_id, ClientState state_min)
{
JMutexAutoLock clientslock(m_clients_mutex);
MutexAutoLock clientslock(m_clients_mutex);
std::map<u16, RemoteClient*>::iterator n;
n = m_clients.find(peer_id);
// The client may not exist; clients are immediately removed if their
@ -725,7 +725,7 @@ RemoteClient* ClientInterface::lockedGetClientNoEx(u16 peer_id, ClientState stat
ClientState ClientInterface::getClientState(u16 peer_id)
{
JMutexAutoLock clientslock(m_clients_mutex);
MutexAutoLock clientslock(m_clients_mutex);
std::map<u16, RemoteClient*>::iterator n;
n = m_clients.find(peer_id);
// The client may not exist; clients are immediately removed if their
@ -738,7 +738,7 @@ ClientState ClientInterface::getClientState(u16 peer_id)
void ClientInterface::setPlayerName(u16 peer_id,std::string name)
{
JMutexAutoLock clientslock(m_clients_mutex);
MutexAutoLock clientslock(m_clients_mutex);
std::map<u16, RemoteClient*>::iterator n;
n = m_clients.find(peer_id);
// The client may not exist; clients are immediately removed if their
@ -749,7 +749,7 @@ void ClientInterface::setPlayerName(u16 peer_id,std::string name)
void ClientInterface::DeleteClient(u16 peer_id)
{
JMutexAutoLock conlock(m_clients_mutex);
MutexAutoLock conlock(m_clients_mutex);
// Error check
std::map<u16, RemoteClient*>::iterator n;
@ -784,7 +784,7 @@ void ClientInterface::DeleteClient(u16 peer_id)
void ClientInterface::CreateClient(u16 peer_id)
{
JMutexAutoLock conlock(m_clients_mutex);
MutexAutoLock conlock(m_clients_mutex);
// Error check
std::map<u16, RemoteClient*>::iterator n;
@ -801,7 +801,7 @@ void ClientInterface::CreateClient(u16 peer_id)
void ClientInterface::event(u16 peer_id, ClientStateEvent event)
{
{
JMutexAutoLock clientlock(m_clients_mutex);
MutexAutoLock clientlock(m_clients_mutex);
// Error check
std::map<u16, RemoteClient*>::iterator n;
@ -823,7 +823,7 @@ void ClientInterface::event(u16 peer_id, ClientStateEvent event)
u16 ClientInterface::getProtocolVersion(u16 peer_id)
{
JMutexAutoLock conlock(m_clients_mutex);
MutexAutoLock conlock(m_clients_mutex);
// Error check
std::map<u16, RemoteClient*>::iterator n;
@ -838,7 +838,7 @@ u16 ClientInterface::getProtocolVersion(u16 peer_id)
void ClientInterface::setClientVersion(u16 peer_id, u8 major, u8 minor, u8 patch, std::string full)
{
JMutexAutoLock conlock(m_clients_mutex);
MutexAutoLock conlock(m_clients_mutex);
// Error check
std::map<u16, RemoteClient*>::iterator n;

12
src/clientiface.h
View File

@ -23,7 +23,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "constants.h"
#include "serialization.h" // for SER_FMT_VER_INVALID
#include "jthread/jmutex.h"
#include "threading/mutex.h"
#include "network/networkpacket.h"
#include <list>
@ -487,10 +487,8 @@ public:
protected:
//TODO find way to avoid this functions
void Lock()
{ m_clients_mutex.Lock(); }
void Unlock()
{ m_clients_mutex.Unlock(); }
void lock() { m_clients_mutex.lock(); }
void unlock() { m_clients_mutex.unlock(); }
std::map<u16, RemoteClient*>& getClientList()
{ return m_clients; }
@ -501,14 +499,14 @@ private:
// Connection
con::Connection* m_con;
JMutex m_clients_mutex;
Mutex m_clients_mutex;
// Connected clients (behind the con mutex)
std::map<u16, RemoteClient*> m_clients;
std::vector<std::string> m_clients_names; //for announcing masterserver
// Environment
ServerEnvironment *m_env;
JMutex m_env_mutex;
Mutex m_env_mutex;
float m_print_info_timer;

22
src/clientmap.cpp
View File

@ -70,7 +70,7 @@ ClientMap::ClientMap(
ClientMap::~ClientMap()
{
/*JMutexAutoLock lock(mesh_mutex);
/*MutexAutoLock lock(mesh_mutex);
if(mesh != NULL)
{
@ -94,7 +94,7 @@ MapSector * ClientMap::emergeSector(v2s16 p2d)
ClientMapSector *sector = new ClientMapSector(this, p2d, m_gamedef);
{
//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
//MutexAutoLock lock(m_sector_mutex); // Bulk comment-out
m_sectors[p2d] = sector;
}
@ -157,12 +157,12 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
}
m_drawlist.clear();
m_camera_mutex.Lock();
m_camera_mutex.lock();
v3f camera_position = m_camera_position;
v3f camera_direction = m_camera_direction;
f32 camera_fov = m_camera_fov;
//v3s16 camera_offset = m_camera_offset;
m_camera_mutex.Unlock();
m_camera_mutex.unlock();
// Use a higher fov to accomodate faster camera movements.
// Blocks are cropped better when they are drawn.
@ -263,7 +263,7 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
Ignore if mesh doesn't exist
*/
{
//JMutexAutoLock lock(block->mesh_mutex);
//MutexAutoLock lock(block->mesh_mutex);
if(block->mesh == NULL){
blocks_in_range_without_mesh++;
@ -433,11 +433,11 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
int crack = m_client->getCrackLevel();
u32 daynight_ratio = m_client->getEnv().getDayNightRatio();
m_camera_mutex.Lock();
m_camera_mutex.lock();
v3f camera_position = m_camera_position;
v3f camera_direction = m_camera_direction;
f32 camera_fov = m_camera_fov;
m_camera_mutex.Unlock();
m_camera_mutex.unlock();
/*
Get all blocks and draw all visible ones
@ -504,7 +504,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
// Mesh animation
{
//JMutexAutoLock lock(block->mesh_mutex);
//MutexAutoLock lock(block->mesh_mutex);
MapBlockMesh *mapBlockMesh = block->mesh;
assert(mapBlockMesh);
// Pretty random but this should work somewhat nicely
@ -534,7 +534,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
Get the meshbuffers of the block
*/
{
//JMutexAutoLock lock(block->mesh_mutex);
//MutexAutoLock lock(block->mesh_mutex);
MapBlockMesh *mapBlockMesh = block->mesh;
assert(mapBlockMesh);
@ -799,9 +799,9 @@ void ClientMap::renderPostFx(CameraMode cam_mode)
// Sadly ISceneManager has no "post effects" render pass, in that case we
// could just register for that and handle it in renderMap().
m_camera_mutex.Lock();
m_camera_mutex.lock();
v3f camera_position = m_camera_position;
m_camera_mutex.Unlock();
m_camera_mutex.unlock();
MapNode n = getNodeNoEx(floatToInt(camera_position, BS));

4
src/clientmap.h
View File

@ -89,7 +89,7 @@ public:
void updateCamera(v3f pos, v3f dir, f32 fov, v3s16 offset)
{
JMutexAutoLock lock(m_camera_mutex);
MutexAutoLock lock(m_camera_mutex);
m_camera_position = pos;
m_camera_direction = dir;
m_camera_fov = fov;
@ -149,7 +149,7 @@ private:
v3f m_camera_direction;
f32 m_camera_fov;
v3s16 m_camera_offset;
JMutex m_camera_mutex;
Mutex m_camera_mutex;
std::map<v3s16, MapBlock*> m_drawlist;

14
src/debug.cpp
View File

@ -26,8 +26,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <stdlib.h>
#include <cstring>
#include <map>
#include "jthread/jmutex.h"
#include "jthread/jmutexautolock.h"
#include "threading/mutex.h"
#include "threading/mutex_auto_lock.h"
#include "config.h"
#ifdef _MSC_VER
@ -229,7 +229,7 @@ void DebugStack::print(std::ostream &os, bool everything)
}
std::map<threadid_t, DebugStack*> g_debug_stacks;
JMutex g_debug_stacks_mutex;
Mutex g_debug_stacks_mutex;
void debug_stacks_init()
{
@ -237,7 +237,7 @@ void debug_stacks_init()
void debug_stacks_print_to(std::ostream &os)
{
JMutexAutoLock lock(g_debug_stacks_mutex);
MutexAutoLock lock(g_debug_stacks_mutex);
os<<"Debug stacks:"<<std::endl;
@ -251,7 +251,7 @@ void debug_stacks_print_to(std::ostream &os)
void debug_stacks_print()
{
JMutexAutoLock lock(g_debug_stacks_mutex);
MutexAutoLock lock(g_debug_stacks_mutex);
DEBUGPRINT("Debug stacks:\n");
@ -273,7 +273,7 @@ DebugStacker::DebugStacker(const char *text)
{
threadid_t threadid = get_current_thread_id();
JMutexAutoLock lock(g_debug_stacks_mutex);
MutexAutoLock lock(g_debug_stacks_mutex);
std::map<threadid_t, DebugStack*>::iterator n;
n = g_debug_stacks.find(threadid);
@ -307,7 +307,7 @@ DebugStacker::DebugStacker(const char *text)
DebugStacker::~DebugStacker()
{
JMutexAutoLock lock(g_debug_stacks_mutex);
MutexAutoLock lock(g_debug_stacks_mutex);
if(m_overflowed == true)
return;

41
src/emerge.cpp
View File

@ -23,7 +23,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#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"
@ -59,7 +59,7 @@ MapgenDesc reg_mapgens[] = {
{"singlenode", new MapgenFactorySinglenode},
};
class EmergeThread : public JThread
class EmergeThread : public Thread
{
public:
Server *m_server;
@ -73,7 +73,6 @@ public:
std::queue<v3s16> blockqueue;
EmergeThread(Server *server, int ethreadid):
JThread(),
m_server(server),
map(NULL),
emerge(NULL),
@ -81,9 +80,10 @@ public:
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);
@ -112,7 +112,7 @@ EmergeManager::EmergeManager(IGameDef *gamedef)
// 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;
@ -141,9 +141,9 @@ EmergeManager::~EmergeManager()
{
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];
@ -196,7 +196,7 @@ void EmergeManager::initMapgens()
Mapgen *EmergeManager::getCurrentMapgen()
{
for (u32 i = 0; i != emergethread.size(); i++) {
if (emergethread[i]->IsSameThread())
if (emergethread[i]->isSameThread())
return emergethread[i]->mapgen;
}
@ -210,7 +210,7 @@ void EmergeManager::startThreads()
return;
for (u32 i = 0; i != emergethread.size(); i++)
emergethread[i]->Start();
emergethread[i]->start();
threads_active = true;
}
@ -223,13 +223,13 @@ void EmergeManager::stopThreads()
// 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;
}
@ -247,7 +247,7 @@ bool EmergeManager::enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate
flags |= BLOCK_EMERGE_ALLOWGEN;
{
JMutexAutoLock queuelock(queuemutex);
MutexAutoLock queuelock(queuemutex);
count = blocks_enqueued.size();
if (count >= qlimit_total)
@ -360,7 +360,7 @@ MapgenSpecificParams *EmergeManager::createMapgenParams(const std::string &mgnam
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;
@ -390,7 +390,7 @@ bool EmergeThread::getBlockOrStartGen(v3s16 p, MapBlock **b,
{
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)
@ -418,10 +418,8 @@ bool EmergeThread::getBlockOrStartGen(v3s16 p, MapBlock **b,
}
void *EmergeThread::Thread()
void *EmergeThread::run()
{
ThreadStarted();
log_register_thread("EmergeThread" + itos(id));
DSTACK(__FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
@ -434,9 +432,7 @@ void *EmergeThread::Thread()
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();
@ -471,7 +467,7 @@ void *EmergeThread::Thread()
{
//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);
@ -538,7 +534,7 @@ void *EmergeThread::Thread()
}
{
JMutexAutoLock queuelock(emerge->queuemutex);
MutexAutoLock queuelock(emerge->queuemutex);
while (!blockqueue.empty())
{
v3s16 p = blockqueue.front();
@ -555,6 +551,5 @@ void *EmergeThread::Thread()
}
END_DEBUG_EXCEPTION_HANDLER(errorstream)
log_deregister_thread();
return NULL;
}

2
src/emerge.h
View File

@ -86,7 +86,7 @@ public:
std::set<u32> gen_notify_on_deco_ids;
//// Block emerge queue data structures
JMutex queuemutex;
Mutex queuemutex;
std::map<v3s16, BlockEmergeData *> blocks_enqueued;
std::map<u16, u16> peer_queue_count;

12
src/environment.cpp
View File

@ -44,7 +44,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "map.h"
#include "emerge.h"
#include "util/serialize.h"
#include "jthread/jmutexautolock.h"
#include "threading/mutex_auto_lock.h"
#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
@ -204,34 +204,34 @@ u32 Environment::getDayNightRatio()
void Environment::setTimeOfDaySpeed(float speed)
{
JMutexAutoLock(this->m_timeofday_lock);
MutexAutoLock(this->m_timeofday_lock);
m_time_of_day_speed = speed;
}
float Environment::getTimeOfDaySpeed()
{
JMutexAutoLock(this->m_timeofday_lock);
MutexAutoLock(this->m_timeofday_lock);
float retval = m_time_of_day_speed;
return retval;
}
void Environment::setTimeOfDay(u32 time)
{
JMutexAutoLock(this->m_time_lock);
MutexAutoLock(this->m_time_lock);
m_time_of_day = time;
m_time_of_day_f = (float)time / 24000.0;
}
u32 Environment::getTimeOfDay()
{
JMutexAutoLock(this->m_time_lock);
MutexAutoLock(this->m_time_lock);
u32 retval = m_time_of_day;
return retval;
}
float Environment::getTimeOfDayF()
{
JMutexAutoLock(this->m_time_lock);
MutexAutoLock(this->m_time_lock);
float retval = m_time_of_day_f;
return retval;
}

6
src/environment.h
View File

@ -39,7 +39,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "util/numeric.h"
#include "mapnode.h"
#include "mapblock.h"
#include "jthread/jmutex.h"
#include "threading/mutex.h"
#include "network/networkprotocol.h" // for AccessDeniedCode
class ServerEnvironment;
@ -127,8 +127,8 @@ protected:
bool m_cache_enable_shaders;
private:
JMutex m_timeofday_lock;
JMutex m_time_lock;
Mutex m_timeofday_lock;
Mutex m_time_lock;
};

38
src/httpfetch.cpp
View File

@ -25,7 +25,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <list>
#include <map>
#include <errno.h>
#include "jthread/jevent.h"
#include "threading/event.h"
#include "config.h"
#include "exceptions.h"
#include "debug.h"
@ -35,7 +35,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "version.h"
#include "settings.h"
JMutex g_httpfetch_mutex;
Mutex g_httpfetch_mutex;
std::map<unsigned long, std::queue<HTTPFetchResult> > g_httpfetch_results;
HTTPFetchRequest::HTTPFetchRequest()
@ -55,7 +55,7 @@ static void httpfetch_deliver_result(const HTTPFetchResult &fetch_result)
{
unsigned long caller = fetch_result.caller;
if (caller != HTTPFETCH_DISCARD) {
JMutexAutoLock lock(g_httpfetch_mutex);
MutexAutoLock lock(g_httpfetch_mutex);
g_httpfetch_results[caller].push(fetch_result);
}
}
@ -64,7 +64,7 @@ static void httpfetch_request_clear(unsigned long caller);
unsigned long httpfetch_caller_alloc()
{
JMutexAutoLock lock(g_httpfetch_mutex);
MutexAutoLock lock(g_httpfetch_mutex);
// Check each caller ID except HTTPFETCH_DISCARD
const unsigned long discard = HTTPFETCH_DISCARD;
@ -91,14 +91,14 @@ void httpfetch_caller_free(unsigned long caller)
httpfetch_request_clear(caller);
if (caller != HTTPFETCH_DISCARD) {
JMutexAutoLock lock(g_httpfetch_mutex);
MutexAutoLock lock(g_httpfetch_mutex);
g_httpfetch_results.erase(caller);
}
}
bool httpfetch_async_get(unsigned long caller, HTTPFetchResult &fetch_result)
{
JMutexAutoLock lock(g_httpfetch_mutex);
MutexAutoLock lock(g_httpfetch_mutex);
// Check that caller exists
std::map<unsigned long, std::queue<HTTPFetchResult> >::iterator
@ -390,7 +390,7 @@ HTTPFetchOngoing::~HTTPFetchOngoing()
}
class CurlFetchThread : public JThread
class CurlFetchThread : public Thread
{
protected:
enum RequestType {
@ -414,7 +414,8 @@ protected:
std::list<HTTPFetchRequest> m_queued_fetches;
public:
CurlFetchThread(int parallel_limit)
CurlFetchThread(int parallel_limit) :
Thread("CurlFetch")
{
if (parallel_limit >= 1)
m_parallel_limit = parallel_limit;
@ -613,14 +614,10 @@ protected:
}
}
void * Thread()
void *run()
{
ThreadStarted();
log_register_thread("CurlFetchThread");
DSTACK(__FUNCTION_NAME);
porting::setThreadName("CurlFetchThread");
CurlHandlePool pool;
m_multi = curl_multi_init();
@ -631,7 +628,7 @@ protected:
FATAL_ERROR_IF(!m_all_ongoing.empty(), "Expected empty");
while (!StopRequested()) {
while (!stopRequested()) {
BEGIN_DEBUG_EXCEPTION_HANDLER
/*
@ -719,9 +716,9 @@ void httpfetch_cleanup()
{
verbosestream<<"httpfetch_cleanup: cleaning up"<<std::endl;
g_httpfetch_thread->Stop();
g_httpfetch_thread->stop();
g_httpfetch_thread->requestWakeUp();
g_httpfetch_thread->Wait();
g_httpfetch_thread->wait();
delete g_httpfetch_thread;
curl_global_cleanup();
@ -730,18 +727,17 @@ void httpfetch_cleanup()
void httpfetch_async(const HTTPFetchRequest &fetch_request)
{
g_httpfetch_thread->requestFetch(fetch_request);
if (!g_httpfetch_thread->IsRunning())
g_httpfetch_thread->Start();
if (!g_httpfetch_thread->isRunning())
g_httpfetch_thread->start();
}
static void httpfetch_request_clear(unsigned long caller)
{
if (g_httpfetch_thread->IsRunning()) {
if (g_httpfetch_thread->isRunning()) {
Event event;
g_httpfetch_thread->requestClear(caller, &event);
event.wait();
}
else {
} else {
g_httpfetch_thread->requestClear(caller, NULL);
}
}

14
src/jthread/CMakeLists.txt
View File

@ -1,14 +0,0 @@
if(UNIX)
set(THREAD_SYS_DIR pthread)
else()
set(THREAD_SYS_DIR win32)
endif()
set(SRC_PREFIX ${CMAKE_CURRENT_SOURCE_DIR}/${THREAD_SYS_DIR})
set(JTHREAD_SRCS
${SRC_PREFIX}/jmutex.cpp
${SRC_PREFIX}/jthread.cpp
${SRC_PREFIX}/jsemaphore.cpp
${SRC_PREFIX}/jevent.cpp
PARENT_SCOPE)

59
src/jthread/jevent.h
View File

@ -1,59 +0,0 @@
/*
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>
#elif defined(__MACH__) && defined(__APPLE__)
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/semaphore.h>
#include <sys/semaphore.h>
#else
#include <semaphore.h>
#endif
class Event {
#ifdef _WIN32
HANDLE hEvent;
#elif defined(__MACH__) && defined(__APPLE__)
semaphore_t sem;
#else
sem_t sem;
#endif
public:
Event();
~Event();
void wait();
void signal();
};
#endif /* JEVENT_H_ */

79
src/jthread/jmutex.h
View File

@ -1,79 +0,0 @@
/*
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 JMUTEX_H
#define JMUTEX_H
#if (defined(WIN32) || defined(_WIN32_WCE))
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif
#ifndef _WIN32_WCE
#include <process.h>
#endif // _WIN32_WCE
#include <winsock2.h>
#include <windows.h>
// CriticalSection is way faster than the alternative
#define JMUTEX_CRITICALSECTION
#else // using pthread
#include <pthread.h>
#endif // WIN32
#define ERR_JMUTEX_ALREADYINIT -1
#define ERR_JMUTEX_NOTINIT -2
#define ERR_JMUTEX_CANTCREATEMUTEX -3
class JMutex
{
public:
JMutex();
~JMutex();
int Lock();
int Unlock();
private:
#if (defined(WIN32) || defined(_WIN32_WCE))
#ifdef JMUTEX_CRITICALSECTION
CRITICAL_SECTION mutex;
#else // Use standard mutex
HANDLE mutex;
#endif // JMUTEX_CRITICALSECTION
#else // pthread mutex
pthread_mutex_t mutex;
bool IsLocked() {
if (pthread_mutex_trylock(&mutex)) {
pthread_mutex_unlock(&mutex);
return true;
}
return false;
}
#endif // WIN32
};
#endif // JMUTEX_H

43
src/jthread/jmutexautolock.h
View File

@ -1,43 +0,0 @@
/*
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 JMUTEXAUTOLOCK_H
#define JMUTEXAUTOLOCK_H
#include "jmutex.h"
class JMutexAutoLock
{
public:
JMutexAutoLock(JMutex &m) : mutex(m) { mutex.Lock(); }
~JMutexAutoLock() { mutex.Unlock(); }
private:
JMutex &mutex;
};
#endif // JMUTEXAUTOLOCK_H

117
src/jthread/jthread.h
View File

@ -1,117 +0,0 @@
/*
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 JTHREAD_H
#define JTHREAD_H
#if __cplusplus >= 201103L
#include <atomic>
#endif
#include "jthread/jmutex.h"
#define ERR_JTHREAD_CANTINITMUTEX -1
#define ERR_JTHREAD_CANTSTARTTHREAD -2
#define ERR_JTHREAD_THREADFUNCNOTSET -3
#define ERR_JTHREAD_NOTRUNNING -4
#define ERR_JTHREAD_ALREADYRUNNING -5
class JThread
{
public:
JThread();
virtual ~JThread();
int Start();
inline void Stop()
{ requeststop = true; }
int Kill();
virtual void *Thread() = 0;
inline bool IsRunning()
{ return running; }
inline bool StopRequested()
{ return requeststop; }
void *GetReturnValue();
bool IsSameThread();
/*
* Wait for thread to finish
* Note: this does not stop a thread you have to do this on your own
* WARNING: never ever call this on a thread not started or already killed!
*/
void Wait();
protected:
void ThreadStarted();
private:
#if (defined(WIN32) || defined(_WIN32_WCE))
#ifdef _WIN32_WCE
DWORD threadid;
static DWORD WINAPI TheThread(void *param);
#else
static UINT __stdcall TheThread(void *param);
UINT threadid;
#endif // _WIN32_WCE
HANDLE threadhandle;
#else // pthread type threads
static void *TheThread(void *param);
pthread_t threadid;
/*
* reading and writing bool values is atomic on all relevant architectures
* ( x86 + arm ). No need to waste time for locking here.
* once C++11 is supported we can tell compiler to handle cpu caches correct
* too. This should cause additional improvement (and silence thread
* concurrency check tools.
*/
#if __cplusplus >= 201103L
std::atomic_bool started;
#else
bool started;
#endif
#endif // WIN32
void *retval;
/*
* reading and writing bool values is atomic on all relevant architectures
* ( x86 + arm ). No need to waste time for locking here.
* once C++11 is supported we can tell compiler to handle cpu caches correct
* too. This should cause additional improvement (and silence thread
* concurrency check tools.
*/
#if __cplusplus >= 201103L
std::atomic_bool running;
std::atomic_bool requeststop;
#else
bool running;
bool requeststop;
#endif
JMutex continuemutex,continuemutex2;
};
#endif // JTHREAD_H

67
src/jthread/pthread/jevent.cpp
View File

@ -1,67 +0,0 @@
/*
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"
#define UNUSED(expr) do { (void)(expr); } while (0)
#if defined(__MACH__) && defined(__APPLE__)
#undef sem_t
#define sem_t semaphore_t
#undef sem_init
#define sem_init(s, p, c) semaphore_create(mach_task_self(), (s), 0, (c))
#undef sem_wait
#define sem_wait(s) semaphore_wait(*(s))
#undef sem_post
#define sem_post(s) semaphore_signal(*(s))
#undef sem_destroy
#define sem_destroy(s) semaphore_destroy(mach_task_self(), *(s))
#endif
Event::Event() {
int sem_init_retval = sem_init(&sem, 0, 0);
assert(sem_init_retval == 0);
UNUSED(sem_init_retval);
}
Event::~Event() {
int sem_destroy_retval = sem_destroy(&sem);
assert(sem_destroy_retval == 0);
UNUSED(sem_destroy_retval);
}
void Event::wait() {
int sem_wait_retval = sem_wait(&sem);
assert(sem_wait_retval == 0);
UNUSED(sem_wait_retval);
}
void Event::signal() {
int sem_post_retval = sem_post(&sem);
assert(sem_post_retval == 0);
UNUSED(sem_post_retval);
}

58
src/jthread/pthread/jmutex.cpp
View File

@ -1,58 +0,0 @@
/*
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/jmutex.h"
#define UNUSED(expr) do { (void)(expr); } while (0)
JMutex::JMutex()
{
int mutex_init_retval = pthread_mutex_init(&mutex,NULL);
assert( mutex_init_retval == 0 );
UNUSED(mutex_init_retval);
}
JMutex::~JMutex()
{
int mutex_dextroy_retval = pthread_mutex_destroy(&mutex);
assert( mutex_dextroy_retval == 0 );
UNUSED(mutex_dextroy_retval);
}
int JMutex::Lock()
{
int mutex_lock_retval = pthread_mutex_lock(&mutex);
assert( mutex_lock_retval == 0 );
return mutex_lock_retval;
UNUSED(mutex_lock_retval);
}
int JMutex::Unlock()
{
int mutex_unlock_retval = pthread_mutex_unlock(&mutex);
assert( mutex_unlock_retval == 0 );
return mutex_unlock_retval;
UNUSED(mutex_unlock_retval);
}

156
src/jthread/pthread/jsemaphore.cpp
View File

@ -1,156 +0,0 @@
/*
Minetest
Copyright (C) 2013 sapier, < sapier AT gmx DOT net >
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
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 <errno.h>
#include <sys/time.h>
#include "jthread/jsemaphore.h"
#if defined(__MACH__) && defined(__APPLE__)
#include <unistd.h>
#endif
#define UNUSED(expr) do { (void)(expr); } while (0)
#if defined(__MACH__) && defined(__APPLE__)
#undef sem_t
#undef sem_init
#undef sem_wait
#undef sem_post
#undef sem_destroy
#define sem_t semaphore_t
#define sem_init(s, p, c) semaphore_create(mach_task_self(), (s), 0, (c))
#define sem_wait(s) semaphore_wait(*(s))
#define sem_post(s) semaphore_signal(*(s))
#define sem_destroy(s) semaphore_destroy(mach_task_self(), *(s))
pthread_mutex_t semcount_mutex;
#endif
JSemaphore::JSemaphore() {
int sem_init_retval = sem_init(&m_semaphore,0,0);
assert(sem_init_retval == 0);
UNUSED(sem_init_retval);
#if defined(__MACH__) && defined(__APPLE__)
semcount = 0;
#endif
}
JSemaphore::~JSemaphore() {
int sem_destroy_retval = sem_destroy(&m_semaphore);
#ifdef __ANDROID__
// WORKAROUND for broken bionic semaphore implementation!
assert(
(sem_destroy_retval == 0) ||
(errno == EBUSY)
);
#else
assert(sem_destroy_retval == 0);
#endif
UNUSED(sem_destroy_retval);
}
JSemaphore::JSemaphore(int initval) {
int sem_init_retval = sem_init(&m_semaphore,0,initval);
assert(sem_init_retval == 0);
UNUSED(sem_init_retval);
}
void JSemaphore::Post() {
int sem_post_retval = sem_post(&m_semaphore);
assert(sem_post_retval == 0);
UNUSED(sem_post_retval);
#if defined(__MACH__) && defined(__APPLE__)
pthread_mutex_lock(&semcount_mutex);
semcount++;
pthread_mutex_unlock(&semcount_mutex);
#endif
}
void JSemaphore::Wait() {
int sem_wait_retval = sem_wait(&m_semaphore);
assert(sem_wait_retval == 0);
UNUSED(sem_wait_retval);
#if defined(__MACH__) && defined(__APPLE__)
pthread_mutex_lock(&semcount_mutex);
semcount--;
pthread_mutex_unlock(&semcount_mutex);
#endif
}
bool JSemaphore::Wait(unsigned int time_ms) {
#if defined(__MACH__) && defined(__APPLE__)
mach_timespec_t waittime;
waittime.tv_sec = time_ms / 1000;
waittime.tv_nsec = 1000000 * (time_ms % 1000);
#else
struct timespec waittime;
#endif
struct timeval now;
if (gettimeofday(&now, NULL) == -1) {
assert("Unable to get time by clock_gettime!" == 0);
return false;
}
#if !(defined(__MACH__) && defined(__APPLE__))
waittime.tv_nsec = ((time_ms % 1000) * 1000 * 1000) + (now.tv_usec * 1000);
waittime.tv_sec = (time_ms / 1000) + (waittime.tv_nsec / (1000*1000*1000)) + now.tv_sec;
waittime.tv_nsec %= 1000*1000*1000;
#endif
errno = 0;
#if defined(__MACH__) && defined(__APPLE__)
int sem_wait_retval = semaphore_timedwait(m_semaphore, waittime);
if (sem_wait_retval == KERN_OPERATION_TIMED_OUT) {
errno = ETIMEDOUT;
} else if (sem_wait_retval == KERN_ABORTED) {
errno = EINTR;
} else if (sem_wait_retval != 0) {
errno = EINVAL;
}
#else
int sem_wait_retval = sem_timedwait(&m_semaphore, &waittime);
#endif
if (sem_wait_retval == 0)
{
#if defined(__MACH__) && defined(__APPLE__)
pthread_mutex_lock(&semcount_mutex);
semcount--;
pthread_mutex_unlock(&semcount_mutex);
#endif
return true;
}
else {
assert((errno == ETIMEDOUT) || (errno == EINTR));
return false;
}
return sem_wait_retval == 0 ? true : false;
}
int JSemaphore::GetValue() {
int retval = 0;
#if defined(__MACH__) && defined(__APPLE__)
pthread_mutex_lock(&semcount_mutex);
retval = semcount;
pthread_mutex_unlock(&semcount_mutex);
#else
sem_getvalue(&m_semaphore, &retval);
#endif
return retval;
}

168
src/jthread/pthread/jthread.cpp
View File

@ -1,168 +0,0 @@
/*
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/jthread.h"
#include <assert.h>
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>
#define UNUSED(expr) do { (void)(expr); } while (0)
JThread::JThread()
{
retval = NULL;
requeststop = false;
running = false;
started = false;
}
JThread::~JThread()
{
Kill();
}
void JThread::Wait() {
void* status;
if (started) {
int pthread_join_retval = pthread_join(threadid,&status);
assert(pthread_join_retval == 0);
UNUSED(pthread_join_retval);
started = false;
}
}
int JThread::Start()
{
int status;
if (running)
{
return ERR_JTHREAD_ALREADYRUNNING;
}
requeststop = false;
pthread_attr_t attr;
pthread_attr_init(&attr);
//pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
continuemutex.Lock();
status = pthread_create(&threadid,&attr,TheThread,this);
pthread_attr_destroy(&attr);
if (status != 0)
{
continuemutex.Unlock();
return ERR_JTHREAD_CANTSTARTTHREAD;
}
/* Wait until 'running' is set */
while (!running)
{
struct timespec req,rem;
req.tv_sec = 0;
req.tv_nsec = 1000000;
nanosleep(&req,&rem);
}
started = true;
continuemutex.Unlock();
continuemutex2.Lock();
continuemutex2.Unlock();
return 0;
}
int JThread::Kill()
{
void* status;
if (!running)
{
if (started) {
int pthread_join_retval = pthread_join(threadid,&status);
assert(pthread_join_retval == 0);
UNUSED(pthread_join_retval);
started = false;
}
return ERR_JTHREAD_NOTRUNNING;
}
#ifdef __ANDROID__
pthread_kill(threadid, SIGKILL);
#else
pthread_cancel(threadid);
#endif
if (started) {
int pthread_join_retval = pthread_join(threadid,&status);
assert(pthread_join_retval == 0);
UNUSED(pthread_join_retval);
started = false;
}
running = false;
return 0;
}
void *JThread::GetReturnValue()
{
void *val;
if (running) {
val = NULL;
} else {
val = retval;
}
return val;
}
bool JThread::IsSameThread()
{
return pthread_equal(pthread_self(), threadid);
}
void *JThread::TheThread(void *param)
{
JThread *jthread = (JThread *)param;
jthread->continuemutex2.Lock();
jthread->running = true;
jthread->continuemutex.Lock();
jthread->continuemutex.Unlock();
jthread->Thread();
jthread->running = false;
return NULL;
}
void JThread::ThreadStarted()
{
continuemutex2.Unlock();
}

43
src/jthread/win32/jevent.cpp
View File

@ -1,43 +0,0 @@
/*
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);
}

68
src/jthread/win32/jmutex.cpp
View File

@ -1,68 +0,0 @@
/*
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/jmutex.h"
JMutex::JMutex()
{
#ifdef JMUTEX_CRITICALSECTION
InitializeCriticalSection(&mutex);
#else
mutex = CreateMutex(NULL,FALSE,NULL);
assert(mutex != NULL);
#endif // JMUTEX_CRITICALSECTION
}
JMutex::~JMutex()
{
#ifdef JMUTEX_CRITICALSECTION
DeleteCriticalSection(&mutex);
#else
CloseHandle(mutex);
#endif // JMUTEX_CRITICALSECTION
}
int JMutex::Lock()
{
#ifdef JMUTEX_CRITICALSECTION
EnterCriticalSection(&mutex);
#else
WaitForSingleObject(mutex,INFINITE);
#endif // JMUTEX_CRITICALSECTION
return 0;
}
int JMutex::Unlock()
{
#ifdef JMUTEX_CRITICALSECTION
LeaveCriticalSection(&mutex);
#else
ReleaseMutex(mutex);
#endif // JMUTEX_CRITICALSECTION
return 0;
}

104
src/jthread/win32/jsemaphore.cpp
View File

@ -1,104 +0,0 @@
/*
Minetest
Copyright (C) 2013 sapier, < sapier AT gmx DOT net >
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "jthread/jsemaphore.h"
JSemaphore::JSemaphore() {
m_hSemaphore = CreateSemaphore(
0,
0,
MAX_SEMAPHORE_COUNT,
0);
}
JSemaphore::~JSemaphore() {
CloseHandle(m_hSemaphore);
}
JSemaphore::JSemaphore(int initval) {
m_hSemaphore = CreateSemaphore(
0,
initval,
MAX_SEMAPHORE_COUNT,
0);
}
void JSemaphore::Post() {
ReleaseSemaphore(
m_hSemaphore,
1,
0);
}
void JSemaphore::Wait() {
WaitForSingleObject(
m_hSemaphore,
INFINITE);
}
bool JSemaphore::Wait(unsigned int time_ms) {
unsigned int retval = WaitForSingleObject(
m_hSemaphore,
time_ms);
if (retval == WAIT_OBJECT_0)
{
return true;
}
else {
assert(retval == WAIT_TIMEOUT);
return false;
}
}
typedef LONG (NTAPI *_NtQuerySemaphore)(
HANDLE SemaphoreHandle,
DWORD SemaphoreInformationClass,
PVOID SemaphoreInformation,
ULONG SemaphoreInformationLength,
PULONG ReturnLength OPTIONAL
);
typedef struct _SEMAPHORE_BASIC_INFORMATION {
ULONG CurrentCount;
ULONG MaximumCount;
} SEMAPHORE_BASIC_INFORMATION;
/* Note: this will only work as long as jthread is directly linked to application */
/* it's gonna fail if someone tries to build jthread as dll */
static _NtQuerySemaphore NtQuerySemaphore =
(_NtQuerySemaphore)
GetProcAddress
(GetModuleHandle ("ntdll.dll"), "NtQuerySemaphore");
int JSemaphore::GetValue() {
SEMAPHORE_BASIC_INFORMATION BasicInfo;
LONG retval;
assert(NtQuerySemaphore);
retval = NtQuerySemaphore (m_hSemaphore, 0,
&BasicInfo, sizeof (SEMAPHORE_BASIC_INFORMATION), NULL);
if (retval == ERROR_SUCCESS)
return BasicInfo.CurrentCount;
assert("unable to read semaphore count" == 0);
return 0;
}

146
src/jthread/win32/jthread.cpp
View File

@ -1,146 +0,0 @@
/*
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/jthread.h"
#include <assert.h>
#define UNUSED(expr) do { (void)(expr); } while (0)
#ifndef _WIN32_WCE
#include <process.h>
#endif // _WIN32_WCE
JThread::JThread()
{
retval = NULL;
requeststop = false;
running = false;
}
JThread::~JThread()
{
Kill();
}
void JThread::Wait() {
if (running)
{
WaitForSingleObject(threadhandle, INFINITE);
}
}
int JThread::Start()
{
if (running)
{
return ERR_JTHREAD_ALREADYRUNNING;
}
requeststop = false;
continuemutex.Lock();
#ifndef _WIN32_WCE
threadhandle = (HANDLE)_beginthreadex(NULL,0,TheThread,this,0,&threadid);
#else
threadhandle = CreateThread(NULL,0,TheThread,this,0,&threadid);
#endif // _WIN32_WCE
if (threadhandle == NULL)
{
continuemutex.Unlock();
return ERR_JTHREAD_CANTSTARTTHREAD;
}
/* Wait until 'running' is set */
while (!running)
{
Sleep(1);
}
continuemutex.Unlock();
continuemutex2.Lock();
continuemutex2.Unlock();
return 0;
}
int JThread::Kill()
{
if (!running)
{
return ERR_JTHREAD_NOTRUNNING;
}
TerminateThread(threadhandle,0);
CloseHandle(threadhandle);
running = false;
return 0;
}
void *JThread::GetReturnValue()
{
void *val;
if (running) {
val = NULL;
} else {
val = retval;
}
return val;
}
bool JThread::IsSameThread()
{
return GetCurrentThreadId() == threadid;
}
#ifndef _WIN32_WCE
UINT __stdcall JThread::TheThread(void *param)
#else
DWORD WINAPI JThread::TheThread(void *param)
#endif // _WIN32_WCE
{
JThread *jthread;
void *ret;
jthread = (JThread *)param;
jthread->continuemutex2.Lock();
jthread->running = true;
jthread->continuemutex.Lock();
jthread->continuemutex.Unlock();
ret = jthread->Thread();
jthread->running = false;
jthread->retval = ret;
CloseHandle(jthread->threadhandle);
return 0;
}
void JThread::ThreadStarted()
{
continuemutex2.Unlock();
}

22
src/log.cpp
View File

@ -24,7 +24,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <sstream>
#include <algorithm>
#include "threads.h"
#include "jthread/jmutexautolock.h"
#include "threading/mutex_auto_lock.h"
#include "debug.h"
#include "gettime.h"
#include "porting.h"
@ -54,8 +54,8 @@ unsigned int android_log_level_mapping[] = {
#endif
std::vector<ILogOutput*> log_outputs[LMT_NUM_VALUES];
std::map<threadid_t, std::string> log_threadnames;
JMutex log_threadnamemutex;
std::map<threadid_t, std::string> log_thread_names;
Mutex log_thread_name_mutex;
void log_add_output(ILogOutput *out, enum LogMessageLevel lev)
{
@ -86,7 +86,7 @@ void log_remove_output(ILogOutput *out)
void log_set_lev_silence(enum LogMessageLevel lev, bool silence)
{
JMutexAutoLock lock(log_threadnamemutex);
MutexAutoLock lock(log_thread_name_mutex);
for (std::vector<ILogOutput *>::iterator it = log_outputs[lev].begin();
it != log_outputs[lev].end(); ++it) {
@ -98,17 +98,17 @@ void log_set_lev_silence(enum LogMessageLevel lev, bool silence)
void log_register_thread(const std::string &name)
{
threadid_t id = get_current_thread_id();
JMutexAutoLock lock(log_threadnamemutex);
MutexAutoLock lock(log_thread_name_mutex);
log_threadnames[id] = name;
log_thread_names[id] = name;
}
void log_deregister_thread()
{
threadid_t id = get_current_thread_id();
JMutexAutoLock lock(log_threadnamemutex);
MutexAutoLock lock(log_thread_name_mutex);
log_threadnames.erase(id);
log_thread_names.erase(id);
}
static std::string get_lev_string(enum LogMessageLevel lev)
@ -130,11 +130,11 @@ static std::string get_lev_string(enum LogMessageLevel lev)
void log_printline(enum LogMessageLevel lev, const std::string &text)
{
JMutexAutoLock lock(log_threadnamemutex);
MutexAutoLock lock(log_thread_name_mutex);
std::string threadname = "(unknown thread)";
std::map<threadid_t, std::string>::const_iterator i;
i = log_threadnames.find(get_current_thread_id());
if(i != log_threadnames.end())
i = log_thread_names.find(get_current_thread_id());
if(i != log_thread_names.end())
threadname = i->second;
std::string levelname = get_lev_string(lev);
std::ostringstream os(std::ios_base::binary);

2
src/main.cpp
View File

@ -153,7 +153,7 @@ int main(int argc, char *argv[])
log_add_output_maxlev(&main_stderr_log_out, LMT_ACTION);
log_add_output_all_levs(&main_dstream_no_stderr_log_out);
log_register_thread("main");
log_register_thread("Main");
Settings cmd_args;
bool cmd_args_ok = get_cmdline_opts(argc, argv, &cmd_args);

2
src/mapblock.cpp
View File

@ -96,7 +96,7 @@ MapBlock::~MapBlock()
{
#ifndef SERVER
{
//JMutexAutoLock lock(mesh_mutex);
//MutexAutoLock lock(mesh_mutex);
if(mesh)
{

6
src/mg_decoration.cpp
View File

@ -139,7 +139,7 @@ size_t Decoration::placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
#if 0
printf("Decoration at (%d %d %d) cut off\n", x, y, z);
//add to queue
JMutexAutoLock cutofflock(cutoff_mutex);
MutexAutoLock cutofflock(cutoff_mutex);
cutoffs.push_back(CutoffData(x, y, z, height));
#endif
}
@ -172,7 +172,7 @@ void Decoration::placeCutoffs(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
// Copy over the cutoffs we're interested in so we don't needlessly hold a lock
{
JMutexAutoLock cutofflock(cutoff_mutex);
MutexAutoLock cutofflock(cutoff_mutex);
for (std::list<CutoffData>::iterator i = cutoffs.begin();
i != cutoffs.end(); ++i) {
CutoffData cutoff = *i;
@ -203,7 +203,7 @@ void Decoration::placeCutoffs(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
// Remove cutoffs that were handled from the cutoff list
{
JMutexAutoLock cutofflock(cutoff_mutex);
MutexAutoLock cutofflock(cutoff_mutex);
for (std::list<CutoffData>::iterator i = cutoffs.begin();
i != cutoffs.end(); ++i) {

2
src/mg_decoration.h
View File

@ -84,7 +84,7 @@ public:
std::set<u8> biomes;
//std::list<CutoffData> cutoffs;
//JMutex cutoff_mutex;
//Mutex cutoff_mutex;
};
class DecoSimple : public Decoration {

20
src/minimap.cpp
View File

@ -20,8 +20,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "minimap.h"
#include <math.h>
#include "logoutputbuffer.h"
#include "jthread/jmutexautolock.h"
#include "jthread/jsemaphore.h"
#include "threading/mutex_auto_lock.h"
#include "threading/semaphore.h"
#include "clientmap.h"
#include "settings.h"
#include "nodedef.h"
@ -52,7 +52,7 @@ MinimapUpdateThread::~MinimapUpdateThread()
bool MinimapUpdateThread::pushBlockUpdate(v3s16 pos, MinimapMapblock *data)
{
JMutexAutoLock lock(m_queue_mutex);
MutexAutoLock lock(m_queue_mutex);
// Find if block is already in queue.
// If it is, update the data and quit.
@ -78,7 +78,7 @@ bool MinimapUpdateThread::pushBlockUpdate(v3s16 pos, MinimapMapblock *data)
bool MinimapUpdateThread::popBlockUpdate(QueuedMinimapUpdate *update)
{
JMutexAutoLock lock(m_queue_mutex);
MutexAutoLock lock(m_queue_mutex);
if (m_update_queue.empty())
return false;
@ -256,13 +256,13 @@ Mapper::Mapper(IrrlichtDevice *device, Client *client)
// Initialize and start thread
m_minimap_update_thread = new MinimapUpdateThread();
m_minimap_update_thread->data = data;
m_minimap_update_thread->Start();
m_minimap_update_thread->start();
}
Mapper::~Mapper()
{
m_minimap_update_thread->Stop();
m_minimap_update_thread->Wait();
m_minimap_update_thread->stop();
m_minimap_update_thread->wait();
m_meshbuffer->drop();
@ -290,7 +290,7 @@ MinimapMode Mapper::getMinimapMode()
void Mapper::toggleMinimapShape()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
data->minimap_shape_round = !data->minimap_shape_round;
g_settings->setBool("minimap_shape_round", data->minimap_shape_round);
@ -312,7 +312,7 @@ void Mapper::setMinimapMode(MinimapMode mode)
if (mode >= MINIMAP_MODE_COUNT)
return;
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
data->is_radar = modedefs[mode].is_radar;
data->scan_height = modedefs[mode].scan_height;
@ -327,7 +327,7 @@ void Mapper::setPos(v3s16 pos)
bool do_update = false;
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
if (pos != data->old_pos) {
data->old_pos = data->pos;

17
src/minimap.h
View File

@ -20,18 +20,19 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#ifndef MINIMAP_HEADER
#define MINIMAP_HEADER
#include <map>
#include <string>
#include <vector>
#include "irrlichttypes_extrabloated.h"
#include "client.h"
#include "voxel.h"
#include "jthread/jmutex.h"
#include "jthread/jsemaphore.h"
#include "threading/mutex.h"
#include "threading/semaphore.h"
#include <map>
#include <string>
#include <vector>
#define MINIMAP_MAX_SX 512
#define MINIMAP_MAX_SY 512
enum MinimapMode {
MINIMAP_MODE_OFF,
MINIMAP_MODE_SURFACEx1,
@ -90,6 +91,7 @@ struct QueuedMinimapUpdate {
class MinimapUpdateThread : public UpdateThread {
public:
MinimapUpdateThread() : UpdateThread("Minimap") {}
virtual ~MinimapUpdateThread();
void getMap(v3s16 pos, s16 size, s16 height, bool radar);
@ -105,11 +107,10 @@ public:
MinimapData *data;
protected:
const char *getName() { return "MinimapUpdateThread"; }
virtual void doUpdate();
private:
JMutex m_queue_mutex;
Mutex m_queue_mutex;
std::deque<QueuedMinimapUpdate> m_update_queue;
std::map<v3s16, MinimapMapblock *> m_blocks_cache;
};
@ -151,7 +152,7 @@ private:
bool m_enable_shaders;
u16 m_surface_mode_scan_height;
f32 m_angle;
JMutex m_mutex;
Mutex m_mutex;
};
#endif

8
src/network/clientpackethandler.cpp
View File

@ -621,7 +621,7 @@ void Client::handleCommand_AnnounceMedia(NetworkPacket* pkt)
// Mesh update thread must be stopped while
// updating content definitions
sanity_check(!m_mesh_update_thread.IsRunning());
sanity_check(!m_mesh_update_thread.isRunning());
for (u16 i = 0; i < num_files; i++) {
std::string name, sha1_base64;
@ -694,7 +694,7 @@ void Client::handleCommand_Media(NetworkPacket* pkt)
// Mesh update thread must be stopped while
// updating content definitions
sanity_check(!m_mesh_update_thread.IsRunning());
sanity_check(!m_mesh_update_thread.isRunning());
for (u32 i=0; i < num_files; i++) {
std::string name;
@ -720,7 +720,7 @@ void Client::handleCommand_NodeDef(NetworkPacket* pkt)
// Mesh update thread must be stopped while
// updating content definitions
sanity_check(!m_mesh_update_thread.IsRunning());
sanity_check(!m_mesh_update_thread.isRunning());
// Decompress node definitions
std::string datastring(pkt->getString(0), pkt->getSize());
@ -747,7 +747,7 @@ void Client::handleCommand_ItemDef(NetworkPacket* pkt)
// Mesh update thread must be stopped while
// updating content definitions
sanity_check(!m_mesh_update_thread.IsRunning());
sanity_check(!m_mesh_update_thread.isRunning());
// Decompress item definitions
std::string datastring(pkt->getString(0), pkt->getSize());

124
src/network/connection.cpp
View File

@ -42,10 +42,10 @@ namespace con
#undef DEBUG_CONNECTION_KBPS
#else
/* this mutex is used to achieve log message consistency */
JMutex log_message_mutex;
Mutex log_message_mutex;
#define LOG(a) \
{ \
JMutexAutoLock loglock(log_message_mutex); \
MutexAutoLock loglock(log_message_mutex); \
a; \
}
#define PROFILE(a) a
@ -209,7 +209,7 @@ ReliablePacketBuffer::ReliablePacketBuffer(): m_list_size(0) {}
void ReliablePacketBuffer::print()
{
JMutexAutoLock listlock(m_list_mutex);
MutexAutoLock listlock(m_list_mutex);
LOG(dout_con<<"Dump of ReliablePacketBuffer:" << std::endl);
unsigned int index = 0;
for(std::list<BufferedPacket>::iterator i = m_list.begin();
@ -223,7 +223,7 @@ void ReliablePacketBuffer::print()
}
bool ReliablePacketBuffer::empty()
{
JMutexAutoLock listlock(m_list_mutex);
MutexAutoLock listlock(m_list_mutex);
return m_list.empty();
}
@ -256,7 +256,7 @@ RPBSearchResult ReliablePacketBuffer::notFound()
}
bool ReliablePacketBuffer::getFirstSeqnum(u16& result)
{
JMutexAutoLock listlock(m_list_mutex);
MutexAutoLock listlock(m_list_mutex);
if (m_list.empty())
return false;
BufferedPacket p = *m_list.begin();
@ -266,7 +266,7 @@ bool ReliablePacketBuffer::getFirstSeqnum(u16& result)
BufferedPacket ReliablePacketBuffer::popFirst()
{
JMutexAutoLock listlock(m_list_mutex);
MutexAutoLock listlock(m_list_mutex);
if (m_list.empty())
throw NotFoundException("Buffer is empty");
BufferedPacket p = *m_list.begin();
@ -283,7 +283,7 @@ BufferedPacket ReliablePacketBuffer::popFirst()
}
BufferedPacket ReliablePacketBuffer::popSeqnum(u16 seqnum)
{
JMutexAutoLock listlock(m_list_mutex);
MutexAutoLock listlock(m_list_mutex);
RPBSearchResult r = findPacket(seqnum);
if (r == notFound()) {
LOG(dout_con<<"Sequence number: " << seqnum
@ -311,7 +311,7 @@ BufferedPacket ReliablePacketBuffer::popSeqnum(u16 seqnum)
}
void ReliablePacketBuffer::insert(BufferedPacket &p,u16 next_expected)
{
JMutexAutoLock listlock(m_list_mutex);
MutexAutoLock listlock(m_list_mutex);
if (p.data.getSize() < BASE_HEADER_SIZE + 3) {
errorstream << "ReliablePacketBuffer::insert(): Invalid data size for "
"reliable packet" << std::endl;
@ -411,7 +411,7 @@ void ReliablePacketBuffer::insert(BufferedPacket &p,u16 next_expected)
void ReliablePacketBuffer::incrementTimeouts(float dtime)
{
JMutexAutoLock listlock(m_list_mutex);
MutexAutoLock listlock(m_list_mutex);
for(std::list<BufferedPacket>::iterator i = m_list.begin();
i != m_list.end(); ++i)
{
@ -423,7 +423,7 @@ void ReliablePacketBuffer::incrementTimeouts(float dtime)
std::list<BufferedPacket> ReliablePacketBuffer::getTimedOuts(float timeout,
unsigned int max_packets)
{
JMutexAutoLock listlock(m_list_mutex);
MutexAutoLock listlock(m_list_mutex);
std::list<BufferedPacket> timed_outs;
for(std::list<BufferedPacket>::iterator i = m_list.begin();
i != m_list.end(); ++i)
@ -446,7 +446,7 @@ std::list<BufferedPacket> ReliablePacketBuffer::getTimedOuts(float timeout,
IncomingSplitBuffer::~IncomingSplitBuffer()
{
JMutexAutoLock listlock(m_map_mutex);
MutexAutoLock listlock(m_map_mutex);
for(std::map<u16, IncomingSplitPacket*>::iterator i = m_buf.begin();
i != m_buf.end(); ++i)
{
@ -459,7 +459,7 @@ IncomingSplitBuffer::~IncomingSplitBuffer()
*/
SharedBuffer<u8> IncomingSplitBuffer::insert(BufferedPacket &p, bool reliable)
{
JMutexAutoLock listlock(m_map_mutex);
MutexAutoLock listlock(m_map_mutex);
u32 headersize = BASE_HEADER_SIZE + 7;
if (p.data.getSize() < headersize) {
errorstream << "Invalid data size for split packet" << std::endl;
@ -546,7 +546,7 @@ void IncomingSplitBuffer::removeUnreliableTimedOuts(float dtime, float timeout)
{
std::list<u16> remove_queue;
{
JMutexAutoLock listlock(m_map_mutex);
MutexAutoLock listlock(m_map_mutex);
for(std::map<u16, IncomingSplitPacket*>::iterator i = m_buf.begin();
i != m_buf.end(); ++i)
{
@ -562,7 +562,7 @@ void IncomingSplitBuffer::removeUnreliableTimedOuts(float dtime, float timeout)
for(std::list<u16>::iterator j = remove_queue.begin();
j != remove_queue.end(); ++j)
{
JMutexAutoLock listlock(m_map_mutex);
MutexAutoLock listlock(m_map_mutex);
LOG(dout_con<<"NOTE: Removing timed out unreliable split packet"<<std::endl);
delete m_buf[*j];
m_buf.erase(*j);
@ -605,13 +605,13 @@ Channel::~Channel()
u16 Channel::readNextIncomingSeqNum()
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
return next_incoming_seqnum;
}
u16 Channel::incNextIncomingSeqNum()
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
u16 retval = next_incoming_seqnum;
next_incoming_seqnum++;
return retval;
@ -619,18 +619,18 @@ u16 Channel::incNextIncomingSeqNum()
u16 Channel::readNextSplitSeqNum()
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
return next_outgoing_split_seqnum;
}
void Channel::setNextSplitSeqNum(u16 seqnum)
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
next_outgoing_split_seqnum = seqnum;
}
u16 Channel::getOutgoingSequenceNumber(bool& successful)
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
u16 retval = next_outgoing_seqnum;
u16 lowest_unacked_seqnumber;
@ -670,7 +670,7 @@ u16 Channel::getOutgoingSequenceNumber(bool& successful)
u16 Channel::readOutgoingSequenceNumber()
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
return next_outgoing_seqnum;
}
@ -686,32 +686,32 @@ bool Channel::putBackSequenceNumber(u16 seqnum)
void Channel::UpdateBytesSent(unsigned int bytes, unsigned int packets)
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
current_bytes_transfered += bytes;
current_packet_successfull += packets;
}
void Channel::UpdateBytesReceived(unsigned int bytes) {
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
current_bytes_received += bytes;
}
void Channel::UpdateBytesLost(unsigned int bytes)
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
current_bytes_lost += bytes;
}
void Channel::UpdatePacketLossCounter(unsigned int count)
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
current_packet_loss += count;
}
void Channel::UpdatePacketTooLateCounter()
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
current_packet_too_late++;
}
@ -731,7 +731,7 @@ void Channel::UpdateTimers(float dtime,bool legacy_peer)
bool reasonable_amount_of_data_transmitted = false;
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
packet_loss = current_packet_loss;
//packet_too_late = current_packet_too_late;
packets_successfull = current_packet_successfull;
@ -802,7 +802,7 @@ void Channel::UpdateTimers(float dtime,bool legacy_peer)
if (bpm_counter > 10.0)
{
{
JMutexAutoLock internal(m_internal_mutex);
MutexAutoLock internal(m_internal_mutex);
cur_kbps =
(((float) current_bytes_transfered)/bpm_counter)/1024.0;
current_bytes_transfered = 0;
@ -903,7 +903,7 @@ bool PeerHelper::operator!=(void* ptr)
bool Peer::IncUseCount()
{
JMutexAutoLock lock(m_exclusive_access_mutex);
MutexAutoLock lock(m_exclusive_access_mutex);
if (!m_pending_deletion)
{
@ -917,7 +917,7 @@ bool Peer::IncUseCount()
void Peer::DecUseCount()
{
{
JMutexAutoLock lock(m_exclusive_access_mutex);
MutexAutoLock lock(m_exclusive_access_mutex);
sanity_check(m_usage > 0);
m_usage--;
@ -978,7 +978,7 @@ void Peer::RTTStatistics(float rtt, std::string profiler_id,
bool Peer::isTimedOut(float timeout)
{
JMutexAutoLock lock(m_exclusive_access_mutex);
MutexAutoLock lock(m_exclusive_access_mutex);
u32 current_time = porting::getTimeMs();
float dtime = CALC_DTIME(m_last_timeout_check,current_time);
@ -992,7 +992,7 @@ bool Peer::isTimedOut(float timeout)
void Peer::Drop()
{
{
JMutexAutoLock usage_lock(m_exclusive_access_mutex);
MutexAutoLock usage_lock(m_exclusive_access_mutex);
m_pending_deletion = true;
if (m_usage != 0)
return;
@ -1051,7 +1051,7 @@ void UDPPeer::reportRTT(float rtt)
if (timeout > RESEND_TIMEOUT_MAX)
timeout = RESEND_TIMEOUT_MAX;
JMutexAutoLock usage_lock(m_exclusive_access_mutex);
MutexAutoLock usage_lock(m_exclusive_access_mutex);
resend_timeout = timeout;
}
@ -1257,6 +1257,7 @@ SharedBuffer<u8> UDPPeer::addSpiltPacket(u8 channel,
ConnectionSendThread::ConnectionSendThread(unsigned int max_packet_size,
float timeout) :
Thread("ConnectionSend"),
m_connection(NULL),
m_max_packet_size(max_packet_size),
m_timeout(timeout),
@ -1266,11 +1267,9 @@ ConnectionSendThread::ConnectionSendThread( unsigned int max_packet_size,
{
}
void * ConnectionSendThread::Thread()
void * ConnectionSendThread::run()
{
assert(m_connection != NULL);
ThreadStarted();
log_register_thread("ConnectionSend");
assert(m_connection);
LOG(dout_con<<m_connection->getDesc()
<<"ConnectionSend thread started"<<std::endl);
@ -1281,21 +1280,19 @@ void * ConnectionSendThread::Thread()
PROFILE(std::stringstream ThreadIdentifier);
PROFILE(ThreadIdentifier << "ConnectionSend: [" << m_connection->getDesc() << "]");
porting::setThreadName("ConnectionSend");
/* if stop is requested don't stop immediately but try to send all */
/* packets first */
while(!StopRequested() || packetsQueued()) {
while(!stopRequested() || packetsQueued()) {
BEGIN_DEBUG_EXCEPTION_HANDLER
PROFILE(ScopeProfiler sp(g_profiler, ThreadIdentifier.str(), SPT_AVG));
m_iteration_packets_avaialble = m_max_data_packets_per_iteration;
/* wait for trigger or timeout */
m_send_sleep_semaphore.Wait(50);
m_send_sleep_semaphore.wait(50);
/* remove all triggers */
while(m_send_sleep_semaphore.Wait(0)) {}
while(m_send_sleep_semaphore.wait(0)) {}
lasttime = curtime;
curtime = porting::getTimeMs();
@ -1328,7 +1325,7 @@ void * ConnectionSendThread::Thread()
void ConnectionSendThread::Trigger()
{
m_send_sleep_semaphore.Post();
m_send_sleep_semaphore.post();
}
bool ConnectionSendThread::packetsQueued()
@ -1984,7 +1981,7 @@ void ConnectionSendThread::sendPackets(float dtime)
}
else if (
( peer->m_increment_packets_remaining > 0) ||
(StopRequested())) {
(stopRequested())) {
rawSendAsPacket(packet.peer_id, packet.channelnum,
packet.data, packet.reliable);
peer->m_increment_packets_remaining--;
@ -2014,15 +2011,14 @@ void ConnectionSendThread::sendAsPacket(u16 peer_id, u8 channelnum,
}
ConnectionReceiveThread::ConnectionReceiveThread(unsigned int max_packet_size) :
Thread("ConnectionReceive"),
m_connection(NULL)
{
}
void * ConnectionReceiveThread::Thread()
void * ConnectionReceiveThread::run()
{
assert(m_connection != NULL);
ThreadStarted();
log_register_thread("ConnectionReceive");
assert(m_connection);
LOG(dout_con<<m_connection->getDesc()
<<"ConnectionReceive thread started"<<std::endl);
@ -2030,15 +2026,13 @@ void * ConnectionReceiveThread::Thread()
PROFILE(std::stringstream ThreadIdentifier);
PROFILE(ThreadIdentifier << "ConnectionReceive: [" << m_connection->getDesc() << "]");
porting::setThreadName("ConnectionReceive");
#ifdef DEBUG_CONNECTION_KBPS
u32 curtime = porting::getTimeMs();
u32 lasttime = curtime;
float debug_print_timer = 0.0;
#endif
while(!StopRequested()) {
while(!stopRequested()) {
BEGIN_DEBUG_EXCEPTION_HANDLER
PROFILE(ScopeProfiler sp(g_profiler, ThreadIdentifier.str(), SPT_AVG));
@ -2684,8 +2678,8 @@ Connection::Connection(u32 protocol_id, u32 max_packet_size, float timeout,
m_sendThread.setParent(this);
m_receiveThread.setParent(this);
m_sendThread.Start();
m_receiveThread.Start();
m_sendThread.start();
m_receiveThread.start();
}
@ -2694,8 +2688,8 @@ Connection::~Connection()
{
m_shutting_down = true;
// request threads to stop
m_sendThread.Stop();
m_receiveThread.Stop();
m_sendThread.stop();
m_receiveThread.stop();
//TODO for some unkonwn reason send/receive threads do not exit as they're
// supposed to be but wait on peer timeout. To speed up shutdown we reduce
@ -2703,8 +2697,8 @@ Connection::~Connection()
m_sendThread.setPeerTimeout(0.5);
// wait for threads to finish
m_sendThread.Wait();
m_receiveThread.Wait();
m_sendThread.wait();
m_receiveThread.wait();
// Delete peers
for(std::map<u16, Peer*>::iterator
@ -2724,7 +2718,7 @@ void Connection::putEvent(ConnectionEvent &e)
PeerHelper Connection::getPeer(u16 peer_id)
{
JMutexAutoLock peerlock(m_peers_mutex);
MutexAutoLock peerlock(m_peers_mutex);
std::map<u16, Peer*>::iterator node = m_peers.find(peer_id);
if (node == m_peers.end()) {
@ -2739,7 +2733,7 @@ PeerHelper Connection::getPeer(u16 peer_id)
PeerHelper Connection::getPeerNoEx(u16 peer_id)
{
JMutexAutoLock peerlock(m_peers_mutex);
MutexAutoLock peerlock(m_peers_mutex);
std::map<u16, Peer*>::iterator node = m_peers.find(peer_id);
if (node == m_peers.end()) {
@ -2755,7 +2749,7 @@ PeerHelper Connection::getPeerNoEx(u16 peer_id)
/* find peer_id for address */
u16 Connection::lookupPeer(Address& sender)
{
JMutexAutoLock peerlock(m_peers_mutex);
MutexAutoLock peerlock(m_peers_mutex);
std::map<u16, Peer*>::iterator j;
j = m_peers.begin();
for(; j != m_peers.end(); ++j)
@ -2794,7 +2788,7 @@ bool Connection::deletePeer(u16 peer_id, bool timeout)
/* lock list as short as possible */
{
JMutexAutoLock peerlock(m_peers_mutex);
MutexAutoLock peerlock(m_peers_mutex);
if (m_peers.find(peer_id) == m_peers.end())
return false;
peer = m_peers[peer_id];
@ -2852,7 +2846,7 @@ void Connection::Connect(Address address)
bool Connection::Connected()
{
JMutexAutoLock peerlock(m_peers_mutex);
MutexAutoLock peerlock(m_peers_mutex);
if (m_peers.size() != 1)
return false;
@ -2987,7 +2981,7 @@ u16 Connection::createPeer(Address& sender, MTProtocols protocol, int fd)
/*
Find an unused peer id
*/
JMutexAutoLock lock(m_peers_mutex);
MutexAutoLock lock(m_peers_mutex);
bool out_of_ids = false;
for(;;) {
// Check if exists
@ -3038,9 +3032,9 @@ u16 Connection::createPeer(Address& sender, MTProtocols protocol, int fd)
void Connection::PrintInfo(std::ostream &out)
{
m_info_mutex.Lock();
m_info_mutex.lock();
out<<getDesc()<<": ";
m_info_mutex.Unlock();
m_info_mutex.unlock();
}
void Connection::PrintInfo()
@ -3091,7 +3085,7 @@ UDPPeer* Connection::createServerPeer(Address& address)
UDPPeer *peer = new UDPPeer(PEER_ID_SERVER, address, this);
{
JMutexAutoLock lock(m_peers_mutex);
MutexAutoLock lock(m_peers_mutex);
m_peers[peer->id] = peer;
m_peer_ids.push_back(peer->id);
}

56
src/network/connection.h
View File

@ -349,7 +349,7 @@ private:
u16 m_oldest_non_answered_ack;
JMutex m_list_mutex;
Mutex m_list_mutex;
};
/*
@ -372,7 +372,7 @@ private:
// Key is seqnum
std::map<u16, IncomingSplitPacket*> m_buf;
JMutex m_map_mutex;
Mutex m_map_mutex;
};
struct OutgoingPacket
@ -519,32 +519,32 @@ public:
void UpdateTimers(float dtime, bool legacy_peer);
const float getCurrentDownloadRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return cur_kbps; };
{ MutexAutoLock lock(m_internal_mutex); return cur_kbps; };
const float getMaxDownloadRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return max_kbps; };
{ MutexAutoLock lock(m_internal_mutex); return max_kbps; };
const float getCurrentLossRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return cur_kbps_lost; };
{ MutexAutoLock lock(m_internal_mutex); return cur_kbps_lost; };
const float getMaxLossRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return max_kbps_lost; };
{ MutexAutoLock lock(m_internal_mutex); return max_kbps_lost; };
const float getCurrentIncomingRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return cur_incoming_kbps; };
{ MutexAutoLock lock(m_internal_mutex); return cur_incoming_kbps; };
const float getMaxIncomingRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return max_incoming_kbps; };
{ MutexAutoLock lock(m_internal_mutex); return max_incoming_kbps; };
const float getAvgDownloadRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return avg_kbps; };
{ MutexAutoLock lock(m_internal_mutex); return avg_kbps; };
const float getAvgLossRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return avg_kbps_lost; };
{ MutexAutoLock lock(m_internal_mutex); return avg_kbps_lost; };
const float getAvgIncomingRateKB()
{ JMutexAutoLock lock(m_internal_mutex); return avg_incoming_kbps; };
{ MutexAutoLock lock(m_internal_mutex); return avg_incoming_kbps; };
const unsigned int getWindowSize() const { return window_size; };
void setWindowSize(unsigned int size) { window_size = size; };
private:
JMutex m_internal_mutex;
Mutex m_internal_mutex;
int window_size;
u16 next_incoming_seqnum;
@ -675,7 +675,7 @@ class Peer {
};
virtual ~Peer() {
JMutexAutoLock usage_lock(m_exclusive_access_mutex);
MutexAutoLock usage_lock(m_exclusive_access_mutex);
FATAL_ERROR_IF(m_usage != 0, "Reference counting failure");
};
@ -692,15 +692,15 @@ class Peer {
virtual bool getAddress(MTProtocols type, Address& toset) = 0;
void ResetTimeout()
{JMutexAutoLock lock(m_exclusive_access_mutex); m_timeout_counter=0.0; };
{MutexAutoLock lock(m_exclusive_access_mutex); m_timeout_counter=0.0; };
bool isTimedOut(float timeout);
void setSentWithID()
{ JMutexAutoLock lock(m_exclusive_access_mutex); m_has_sent_with_id = true; };
{ MutexAutoLock lock(m_exclusive_access_mutex); m_has_sent_with_id = true; };
bool hasSentWithID()
{ JMutexAutoLock lock(m_exclusive_access_mutex); return m_has_sent_with_id; };
{ MutexAutoLock lock(m_exclusive_access_mutex); return m_has_sent_with_id; };
unsigned int m_increment_packets_remaining;
unsigned int m_increment_bytes_remaining;
@ -744,7 +744,7 @@ class Peer {
bool IncUseCount();
void DecUseCount();
JMutex m_exclusive_access_mutex;
Mutex m_exclusive_access_mutex;
bool m_pending_deletion;
@ -826,10 +826,10 @@ protected:
unsigned int maxtransfer);
float getResendTimeout()
{ JMutexAutoLock lock(m_exclusive_access_mutex); return resend_timeout; }
{ MutexAutoLock lock(m_exclusive_access_mutex); return resend_timeout; }
void setResendTimeout(float timeout)
{ JMutexAutoLock lock(m_exclusive_access_mutex); resend_timeout = timeout; }
{ MutexAutoLock lock(m_exclusive_access_mutex); resend_timeout = timeout; }
bool Ping(float dtime,SharedBuffer<u8>& data);
Channel channels[CHANNEL_COUNT];
@ -910,14 +910,14 @@ struct ConnectionEvent
}
};
class ConnectionSendThread : public JThread {
class ConnectionSendThread : public Thread {
public:
friend class UDPPeer;
ConnectionSendThread(unsigned int max_packet_size, float timeout);
void * Thread ();
void *run();
void Trigger();
@ -961,7 +961,7 @@ private:
unsigned int m_max_packet_size;
float m_timeout;
std::queue<OutgoingPacket> m_outgoing_queue;
JSemaphore m_send_sleep_semaphore;
Semaphore m_send_sleep_semaphore;
unsigned int m_iteration_packets_avaialble;
unsigned int m_max_commands_per_iteration;
@ -969,14 +969,14 @@ private:
unsigned int m_max_packets_requeued;
};
class ConnectionReceiveThread : public JThread {
class ConnectionReceiveThread : public Thread {
public:
ConnectionReceiveThread(unsigned int max_packet_size);
void * Thread ();
void *run();
void setParent(Connection *parent) {
assert(parent != NULL); // Pre-condition
assert(parent); // Pre-condition
m_connection = parent;
}
@ -1054,7 +1054,7 @@ protected:
std::list<u16> getPeerIDs()
{
JMutexAutoLock peerlock(m_peers_mutex);
MutexAutoLock peerlock(m_peers_mutex);
return m_peer_ids;
}
@ -1075,12 +1075,12 @@ private:
std::map<u16, Peer*> m_peers;
std::list<u16> m_peer_ids;
JMutex m_peers_mutex;
Mutex m_peers_mutex;
ConnectionSendThread m_sendThread;
ConnectionReceiveThread m_receiveThread;
JMutex m_info_mutex;
Mutex m_info_mutex;
// Backwards compatibility
PeerHandler *m_bc_peerhandler;

16
src/particles.cpp
View File

@ -347,7 +347,7 @@ void ParticleManager::step(float dtime)
void ParticleManager::stepSpawners (float dtime)
{
JMutexAutoLock lock(m_spawner_list_lock);
MutexAutoLock lock(m_spawner_list_lock);
for(std::map<u32, ParticleSpawner*>::iterator i =
m_particle_spawners.begin();
i != m_particle_spawners.end();)
@ -367,7 +367,7 @@ void ParticleManager::stepSpawners (float dtime)
void ParticleManager::stepParticles (float dtime)
{
JMutexAutoLock lock(m_particle_list_lock);
MutexAutoLock lock(m_particle_list_lock);
for(std::vector<Particle*>::iterator i = m_particles.begin();
i != m_particles.end();)
{
@ -387,8 +387,8 @@ void ParticleManager::stepParticles (float dtime)
void ParticleManager::clearAll ()
{
JMutexAutoLock lock(m_spawner_list_lock);
JMutexAutoLock lock2(m_particle_list_lock);
MutexAutoLock lock(m_spawner_list_lock);
MutexAutoLock lock2(m_particle_list_lock);
for(std::map<u32, ParticleSpawner*>::iterator i =
m_particle_spawners.begin();
i != m_particle_spawners.end();)
@ -411,7 +411,7 @@ void ParticleManager::handleParticleEvent(ClientEvent *event, IGameDef *gamedef,
scene::ISceneManager* smgr, LocalPlayer *player)
{
if (event->type == CE_DELETE_PARTICLESPAWNER) {
JMutexAutoLock lock(m_spawner_list_lock);
MutexAutoLock lock(m_spawner_list_lock);
if (m_particle_spawners.find(event->delete_particlespawner.id) !=
m_particle_spawners.end())
{
@ -425,7 +425,7 @@ void ParticleManager::handleParticleEvent(ClientEvent *event, IGameDef *gamedef,
if (event->type == CE_ADD_PARTICLESPAWNER) {
{
JMutexAutoLock lock(m_spawner_list_lock);
MutexAutoLock lock(m_spawner_list_lock);
if (m_particle_spawners.find(event->add_particlespawner.id) !=
m_particle_spawners.end())
{
@ -465,7 +465,7 @@ void ParticleManager::handleParticleEvent(ClientEvent *event, IGameDef *gamedef,
delete event->add_particlespawner.maxacc;
{
JMutexAutoLock lock(m_spawner_list_lock);
MutexAutoLock lock(m_spawner_list_lock);
m_particle_spawners.insert(
std::pair<u32, ParticleSpawner*>(
event->add_particlespawner.id,
@ -568,6 +568,6 @@ void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* s
void ParticleManager::addParticle(Particle* toadd)
{
JMutexAutoLock lock(m_particle_list_lock);
MutexAutoLock lock(m_particle_list_lock);
m_particles.push_back(toadd);
}

4
src/particles.h
View File

@ -190,8 +190,8 @@ private:
std::map<u32, ParticleSpawner*> m_particle_spawners;
ClientEnvironment* m_env;
JMutex m_particle_list_lock;
JMutex m_spawner_list_lock;
Mutex m_particle_list_lock;
Mutex m_spawner_list_lock;
};
#endif

10
src/player.cpp
View File

@ -20,7 +20,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "player.h"
#include <fstream>
#include "jthread/jmutexautolock.h"
#include "threading/mutex_auto_lock.h"
#include "util/numeric.h"
#include "hud.h"
#include "constants.h"
@ -217,7 +217,7 @@ void Player::deSerialize(std::istream &is, std::string playername)
u32 Player::addHud(HudElement *toadd)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
u32 id = getFreeHudID();
@ -231,7 +231,7 @@ u32 Player::addHud(HudElement *toadd)
HudElement* Player::getHud(u32 id)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
if (id < hud.size())
return hud[id];
@ -241,7 +241,7 @@ HudElement* Player::getHud(u32 id)
HudElement* Player::removeHud(u32 id)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
HudElement* retval = NULL;
if (id < hud.size()) {
@ -253,7 +253,7 @@ HudElement* Player::removeHud(u32 id)
void Player::clearHud()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
while(!hud.empty()) {
delete hud.back();

4
src/player.h
View File

@ -23,7 +23,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "irrlichttypes_bloated.h"
#include "inventory.h"
#include "constants.h" // BS
#include "jthread/jmutex.h"
#include "threading/mutex.h"
#include <list>
#define PLAYERNAME_SIZE 20
@ -413,7 +413,7 @@ private:
// Protect some critical areas
// hud for example can be modified by EmergeThread
// and ServerThread
JMutex m_mutex;
Mutex m_mutex;
};

124
src/porting.cpp
View File

@ -129,130 +129,6 @@ void signal_handler_init(void)
#endif
/*
Multithreading support
*/
int getNumberOfProcessors()
{
#if defined(_SC_NPROCESSORS_ONLN)
return sysconf(_SC_NPROCESSORS_ONLN);
#elif defined(__FreeBSD__) || defined(__APPLE__)
unsigned int len, count;
len = sizeof(count);
return sysctlbyname("hw.ncpu", &count, &len, NULL, 0);
#elif defined(_GNU_SOURCE)
return get_nprocs();
#elif defined(_WIN32)
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
return sysinfo.dwNumberOfProcessors;
#elif defined(PTW32_VERSION) || defined(__hpux)
return pthread_num_processors_np();
#else
return 1;
#endif
}
#ifndef __ANDROID__
bool threadBindToProcessor(threadid_t tid, int pnumber)
{
#if defined(_WIN32)
HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, 0, tid);
if (!hThread)
return false;
bool success = SetThreadAffinityMask(hThread, 1 << pnumber) != 0;
CloseHandle(hThread);
return success;
#elif (defined(__FreeBSD__) && (__FreeBSD_version >= 702106)) \
|| defined(__linux) || defined(linux)
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(pnumber, &cpuset);
return pthread_setaffinity_np(tid, sizeof(cpuset), &cpuset) == 0;
#elif defined(__sun) || defined(sun)
return processor_bind(P_LWPID, MAKE_LWPID_PTHREAD(tid),
pnumber, NULL) == 0;
#elif defined(_AIX)
return bindprocessor(BINDTHREAD, (tid_t)tid, pnumber) == 0;
#elif defined(__hpux) || defined(hpux)
pthread_spu_t answer;
return pthread_processor_bind_np(PTHREAD_BIND_ADVISORY_NP,
&answer, pnumber, tid) == 0;
#elif defined(__APPLE__)
struct thread_affinity_policy tapol;
thread_port_t threadport = pthread_mach_thread_np(tid);
tapol.affinity_tag = pnumber + 1;
return thread_policy_set(threadport, THREAD_AFFINITY_POLICY,
(thread_policy_t)&tapol, THREAD_AFFINITY_POLICY_COUNT) == KERN_SUCCESS;
#else
return false;
#endif
}
#endif
bool threadSetPriority(threadid_t tid, int prio)
{
#if defined(_WIN32)
HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, 0, tid);
if (!hThread)
return false;
bool success = SetThreadPriority(hThread, prio) != 0;
CloseHandle(hThread);
return success;
#else
struct sched_param sparam;
int policy;
if (pthread_getschedparam(tid, &policy, &sparam) != 0)
return false;
int min = sched_get_priority_min(policy);
int max = sched_get_priority_max(policy);
sparam.sched_priority = min + prio * (max - min) / THREAD_PRIORITY_HIGHEST;
return pthread_setschedparam(tid, policy, &sparam) == 0;
#endif
}
/*
Path mangler
*/

89
src/porting.h
View File

@ -64,28 +64,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#define _GNU_SOURCE
#endif
#include <sched.h>
#ifdef __FreeBSD__
#include <pthread_np.h>
typedef cpuset_t cpu_set_t;
#elif defined(__sun) || defined(sun)
#include <sys/types.h>
#include <sys/processor.h>
#elif defined(_AIX)
#include <sys/processor.h>
#elif __APPLE__
#include <mach/mach_init.h>
#include <mach/thread_policy.h>
#endif
#define sleep_ms(x) usleep(x*1000)
#define THREAD_PRIORITY_LOWEST 0
#define THREAD_PRIORITY_BELOW_NORMAL 1
#define THREAD_PRIORITY_NORMAL 2
#define THREAD_PRIORITY_ABOVE_NORMAL 3
#define THREAD_PRIORITY_HIGHEST 4
#endif
#ifdef _MSC_VER
@ -165,21 +144,6 @@ std::string getDataPath(const char *subpath);
*/
void initializePaths();
/*
Get number of online processors in the system.
*/
int getNumberOfProcessors();
/*
Set a thread's affinity to a particular processor.
*/
bool threadBindToProcessor(threadid_t tid, int pnumber);
/*
Set a thread's priority.
*/
bool threadSetPriority(threadid_t tid, int prio);
/*
Return system information
e.g. "Linux/3.12.7 x86_64"
@ -311,59 +275,6 @@ inline u32 getDeltaMs(u32 old_time_ms, u32 new_time_ms)
}
}
#if defined(linux) || defined(__linux)
#include <sys/prctl.h>
inline void setThreadName(const char *name) {
/* It would be cleaner to do this with pthread_setname_np,
* which was added to glibc in version 2.12, but some major
* distributions are still runing 2.11 and previous versions.
*/
prctl(PR_SET_NAME, name);
}
#elif defined(__FreeBSD__) || defined(__OpenBSD__)
#include <pthread.h>
#include <pthread_np.h>
inline void setThreadName(const char *name) {
pthread_set_name_np(pthread_self(), name);
}
#elif defined(__NetBSD__)
#include <pthread.h>
inline void setThreadName(const char *name) {
pthread_setname_np(pthread_self(), name);
}
#elif defined(_MSC_VER)
typedef struct tagTHREADNAME_INFO {
DWORD dwType; // must be 0x1000
LPCSTR szName; // pointer to name (in user addr space)
DWORD dwThreadID; // thread ID (-1=caller thread)
DWORD dwFlags; // reserved for future use, must be zero
} THREADNAME_INFO;
inline void setThreadName(const char *name) {
THREADNAME_INFO info;
info.dwType = 0x1000;
info.szName = name;
info.dwThreadID = -1;
info.dwFlags = 0;
__try {
RaiseException(0x406D1388, 0, sizeof(info) / sizeof(DWORD), (ULONG_PTR *) &info);
} __except (EXCEPTION_CONTINUE_EXECUTION) {}
}
#elif defined(__APPLE__)
#include <pthread.h>
inline void setThreadName(const char *name) {
pthread_setname_np(name);
}
#elif defined(_WIN32) || defined(__GNU__)
inline void setThreadName(const char* name) {}
#else
#warning "Unrecognized platform, thread names will not be available."
inline void setThreadName(const char* name) {}
#endif
#ifndef SERVER
float getDisplayDensity();

13
src/porting_android.cpp
View File

@ -23,6 +23,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "porting.h"
#include "porting_android.h"
#include "threading/thread.h"
#include "config.h"
#include "filesys.h"
#include "log.h"
@ -39,30 +40,28 @@ void android_main(android_app *app)
int retval = 0;
porting::app_global = app;
porting::setThreadName("MainThread");
Thread::setName("MainThread");
try {
app_dummy();
char *argv[] = {(char*) "minetest"};
main(sizeof(argv) / sizeof(argv[0]), argv);
}
catch(BaseException e) {
} catch (BaseException &e) {
std::stringstream msg;
msg << "Exception handled by main: " << e.what();
const char *message = msg.str().c_str();
__android_log_print(ANDROID_LOG_ERROR, PROJECT_NAME, "%s", message);
errorstream << msg << std::endl;
retval = -1;
}
catch(...) {
} catch (...) {
__android_log_print(ANDROID_LOG_ERROR, PROJECT_NAME,
"Some exception occured");
"An unknown exception occured!");
errorstream << "Uncaught exception in main thread!" << std::endl;
retval = -1;
}
porting::cleanupAndroid();
errorstream << "Shutting down minetest." << std::endl;
errorstream << "Shutting down." << std::endl;
exit(retval);
}

20
src/profiler.h
View File

@ -24,8 +24,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <string>
#include <map>
#include "jthread/jmutex.h"
#include "jthread/jmutexautolock.h"
#include "threading/mutex.h"
#include "threading/mutex_auto_lock.h"
#include "util/timetaker.h"
#include "util/numeric.h" // paging()
#include "debug.h" // assert()
@ -49,7 +49,7 @@ public:
void add(const std::string &name, float value)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
{
/* No average shall have been used; mark add used as -2 */
std::map<std::string, int>::iterator n = m_avgcounts.find(name);
@ -72,7 +72,7 @@ public:
void avg(const std::string &name, float value)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
int &count = m_avgcounts[name];
assert(count != -2);
@ -82,7 +82,7 @@ public:
void clear()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
for(std::map<std::string, float>::iterator
i = m_data.begin();
i != m_data.end(); ++i)
@ -114,7 +114,7 @@ public:
void printPage(std::ostream &o, u32 page, u32 pagecount)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
u32 minindex, maxindex;
paging(m_data.size(), page, pagecount, minindex, maxindex);
@ -159,7 +159,7 @@ public:
void graphAdd(const std::string &id, float value)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
std::map<std::string, float>::iterator i =
m_graphvalues.find(id);
if(i == m_graphvalues.end())
@ -169,20 +169,20 @@ public:
}
void graphGet(GraphValues &result)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
result = m_graphvalues;
m_graphvalues.clear();
}
void remove(const std::string& name)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
m_avgcounts.erase(name);
m_data.erase(name);
}
private:
JMutex m_mutex;
Mutex m_mutex;
std::map<std::string, float> m_data;
std::map<std::string, int> m_avgcounts;
std::map<std::string, float> m_graphvalues;

14
src/quicktune.cpp
View File

@ -18,8 +18,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
*/
#include "quicktune.h"
#include "jthread/jmutex.h"
#include "jthread/jmutexautolock.h"
#include "threading/mutex.h"
#include "threading/mutex_auto_lock.h"
#include "util/string.h"
std::string QuicktuneValue::getString()
@ -49,12 +49,12 @@ void QuicktuneValue::relativeAdd(float amount)
static std::map<std::string, QuicktuneValue> g_values;
static std::vector<std::string> g_names;
JMutex *g_mutex = NULL;
Mutex *g_mutex = NULL;
static void makeMutex()
{
if(!g_mutex){
g_mutex = new JMutex();
g_mutex = new Mutex();
}
}
@ -66,7 +66,7 @@ std::vector<std::string> getQuicktuneNames()
QuicktuneValue getQuicktuneValue(const std::string &name)
{
makeMutex();
JMutexAutoLock lock(*g_mutex);
MutexAutoLock lock(*g_mutex);
std::map<std::string, QuicktuneValue>::iterator i = g_values.find(name);
if(i == g_values.end()){
QuicktuneValue val;
@ -79,7 +79,7 @@ QuicktuneValue getQuicktuneValue(const std::string &name)
void setQuicktuneValue(const std::string &name, const QuicktuneValue &val)
{
makeMutex();
JMutexAutoLock lock(*g_mutex);
MutexAutoLock lock(*g_mutex);
g_values[name] = val;
g_values[name].modified = true;
}
@ -87,7 +87,7 @@ void setQuicktuneValue(const std::string &name, const QuicktuneValue &val)
void updateQuicktuneValue(const std::string &name, QuicktuneValue &val)
{
makeMutex();
JMutexAutoLock lock(*g_mutex);
MutexAutoLock lock(*g_mutex);
std::map<std::string, QuicktuneValue>::iterator i = g_values.find(name);
if(i == g_values.end()){
g_values[name] = val;

68
src/script/cpp_api/s_async.cpp
View File

@ -47,32 +47,31 @@ AsyncEngine::~AsyncEngine()
// Request all threads to stop
for (std::vector<AsyncWorkerThread *>::iterator it = workerThreads.begin();
it != workerThreads.end(); it++) {
(*it)->Stop();
(*it)->stop();
}
// Wake up all threads
for (std::vector<AsyncWorkerThread *>::iterator it = workerThreads.begin();
it != workerThreads.end(); it++) {
jobQueueCounter.Post();
jobQueueCounter.post();
}
// Wait for threads to finish
for (std::vector<AsyncWorkerThread *>::iterator it = workerThreads.begin();
it != workerThreads.end(); it++) {
(*it)->Wait();
(*it)->wait();
}
// Force kill all threads
for (std::vector<AsyncWorkerThread *>::iterator it = workerThreads.begin();
it != workerThreads.end(); it++) {
(*it)->Kill();
delete *it;
}
jobQueueMutex.Lock();
jobQueueMutex.lock();
jobQueue.clear();
jobQueueMutex.Unlock();
jobQueueMutex.unlock();
workerThreads.clear();
}
@ -92,16 +91,17 @@ void AsyncEngine::initialize(unsigned int numEngines)
initDone = true;
for (unsigned int i = 0; i < numEngines; i++) {
AsyncWorkerThread *toAdd = new AsyncWorkerThread(this, i);
AsyncWorkerThread *toAdd = new AsyncWorkerThread(this,
std::string("AsyncWorker-") + itos(i));
workerThreads.push_back(toAdd);
toAdd->Start();
toAdd->start();
}
}
/******************************************************************************/
unsigned int AsyncEngine::queueAsyncJob(std::string func, std::string params)
{
jobQueueMutex.Lock();
jobQueueMutex.lock();
LuaJobInfo toAdd;
toAdd.id = jobIdCounter++;
toAdd.serializedFunction = func;
@ -109,9 +109,9 @@ unsigned int AsyncEngine::queueAsyncJob(std::string func, std::string params)
jobQueue.push_back(toAdd);
jobQueueCounter.Post();
jobQueueCounter.post();
jobQueueMutex.Unlock();
jobQueueMutex.unlock();
return toAdd.id;
}
@ -119,8 +119,8 @@ unsigned int AsyncEngine::queueAsyncJob(std::string func, std::string params)
/******************************************************************************/
LuaJobInfo AsyncEngine::getJob()
{
jobQueueCounter.Wait();
jobQueueMutex.Lock();
jobQueueCounter.wait();
jobQueueMutex.lock();
LuaJobInfo retval;
retval.valid = false;
@ -130,7 +130,7 @@ LuaJobInfo AsyncEngine::getJob()
jobQueue.pop_front();
retval.valid = true;
}
jobQueueMutex.Unlock();
jobQueueMutex.unlock();
return retval;
}
@ -138,16 +138,16 @@ LuaJobInfo AsyncEngine::getJob()
/******************************************************************************/
void AsyncEngine::putJobResult(LuaJobInfo result)
{
resultQueueMutex.Lock();
resultQueueMutex.lock();
resultQueue.push_back(result);
resultQueueMutex.Unlock();
resultQueueMutex.unlock();
}
/******************************************************************************/
void AsyncEngine::step(lua_State *L, int errorhandler)
{
lua_getglobal(L, "core");
resultQueueMutex.Lock();
resultQueueMutex.lock();
while (!resultQueue.empty()) {
LuaJobInfo jobDone = resultQueue.front();
resultQueue.pop_front();
@ -166,14 +166,14 @@ void AsyncEngine::step(lua_State *L, int errorhandler)
PCALL_RESL(L, lua_pcall(L, 2, 0, errorhandler));
}
resultQueueMutex.Unlock();
resultQueueMutex.unlock();
lua_pop(L, 1); // Pop core
}
/******************************************************************************/
void AsyncEngine::pushFinishedJobs(lua_State* L) {
// Result Table
resultQueueMutex.Lock();
MutexAutoLock l(resultQueueMutex);
unsigned int index = 1;
lua_createtable(L, resultQueue.size(), 0);
@ -197,8 +197,6 @@ void AsyncEngine::pushFinishedJobs(lua_State* L) {
lua_rawseti(L, top, index++);
}
resultQueueMutex.Unlock();
}
/******************************************************************************/
@ -214,10 +212,10 @@ void AsyncEngine::prepareEnvironment(lua_State* L, int top)
/******************************************************************************/
AsyncWorkerThread::AsyncWorkerThread(AsyncEngine* jobDispatcher,
unsigned int threadNum) :
const std::string &name) :
Thread(name),
ScriptApiBase(),
jobDispatcher(jobDispatcher),
threadnum(threadNum)
jobDispatcher(jobDispatcher)
{
lua_State *L = getStack();
@ -235,27 +233,17 @@ AsyncWorkerThread::AsyncWorkerThread(AsyncEngine* jobDispatcher,
/******************************************************************************/
AsyncWorkerThread::~AsyncWorkerThread()
{
sanity_check(IsRunning() == false);
sanity_check(!isRunning());
}
/******************************************************************************/
void* AsyncWorkerThread::Thread()
void* AsyncWorkerThread::run()
{
ThreadStarted();
// Register thread for error logging
char number[21];
snprintf(number, sizeof(number), "%u", threadnum);
log_register_thread(std::string("AsyncWorkerThread_") + number);
porting::setThreadName((std::string("AsyncWorkTh_") + number).c_str());
lua_State *L = getStack();
std::string script = getServer()->getBuiltinLuaPath() + DIR_DELIM + "init.lua";
if (!loadScript(script)) {
errorstream
<< "AsyncWorkerThread execution of async base environment failed!"
errorstream << "execution of async base environment failed!"
<< std::endl;
abort();
}
@ -267,11 +255,11 @@ void* AsyncWorkerThread::Thread()
}
// Main loop
while (!StopRequested()) {
while (!stopRequested()) {
// Wait for job
LuaJobInfo toProcess = jobDispatcher->getJob();
if (toProcess.valid == false || StopRequested()) {
if (toProcess.valid == false || stopRequested()) {
continue;
}
@ -310,8 +298,6 @@ void* AsyncWorkerThread::Thread()
lua_pop(L, 1); // Pop core
log_deregister_thread();
return 0;
}

27
src/script/cpp_api/s_async.h
View File

@ -24,9 +24,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <deque>
#include <map>
#include "jthread/jthread.h"
#include "jthread/jmutex.h"
#include "jthread/jsemaphore.h"
#include "threading/thread.h"
#include "threading/mutex.h"
#include "threading/semaphore.h"
#include "debug.h"
#include "lua.h"
#include "cpp_api/s_base.h"
@ -52,24 +52,15 @@ struct LuaJobInfo {
};
// Asynchronous working environment
class AsyncWorkerThread : public JThread, public ScriptApiBase {
class AsyncWorkerThread : public Thread, public ScriptApiBase {
public:
/**
* default constructor
* @param pointer to job dispatcher
*/
AsyncWorkerThread(AsyncEngine* jobDispatcher, unsigned int threadNum);
AsyncWorkerThread(AsyncEngine* jobDispatcher, const std::string &name);
virtual ~AsyncWorkerThread();
void *Thread();
void *run();
private:
AsyncEngine *jobDispatcher;
// Thread number. Used for debug output
unsigned int threadnum;
};
// Asynchornous thread and job management
@ -148,13 +139,13 @@ private:
unsigned int jobIdCounter;
// Mutex to protect job queue
JMutex jobQueueMutex;
Mutex jobQueueMutex;
// Job queue
std::deque<LuaJobInfo> jobQueue;
// Mutex to protect result queue
JMutex resultQueueMutex;
Mutex resultQueueMutex;
// Result queue
std::deque<LuaJobInfo> resultQueue;
@ -162,7 +153,7 @@ private:
std::vector<AsyncWorkerThread*> workerThreads;
// Counter semaphore for job dispatching
JSemaphore jobQueueCounter;
Semaphore jobQueueCounter;
};
#endif // CPP_API_ASYNC_EVENTS_HEADER

6
src/script/cpp_api/s_base.h
View File

@ -28,8 +28,8 @@ extern "C" {
}
#include "irrlichttypes.h"
#include "jthread/jmutex.h"
#include "jthread/jmutexautolock.h"
#include "threading/mutex.h"
#include "threading/mutex_auto_lock.h"
#include "common/c_types.h"
#include "common/c_internal.h"
@ -108,7 +108,7 @@ protected:
void objectrefGetOrCreate(lua_State *L, ServerActiveObject *cobj);
void objectrefGet(lua_State *L, u16 id);
JMutex m_luastackmutex;
Mutex m_luastackmutex;
std::string m_last_run_mod;
// Stack index of Lua error handler
int m_errorhandler;

2
src/script/cpp_api/s_internal.h
View File

@ -53,7 +53,7 @@ bool* m_variable;
#endif
#define SCRIPTAPI_PRECHECKHEADER \
JMutexAutoLock(this->m_luastackmutex); \
MutexAutoLock(this->m_luastackmutex); \
SCRIPTAPI_LOCK_CHECK; \
realityCheck(); \
lua_State *L = getStack(); \

106
src/server.cpp
View File

@ -26,7 +26,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "ban.h"
#include "environment.h"
#include "map.h"
#include "jthread/jmutexautolock.h"
#include "threading/mutex_auto_lock.h"
#include "constants.h"
#include "voxel.h"
#include "config.h"
@ -71,35 +71,29 @@ public:
{}
};
class ServerThread : public JThread
class ServerThread : public Thread
{
Server *m_server;
public:
ServerThread(Server *server):
JThread(),
Thread("Server"),
m_server(server)
{
}
{}
void * Thread();
void *run();
private:
Server *m_server;
};
void *ServerThread::Thread()
void *ServerThread::run()
{
log_register_thread("ServerThread");
DSTACK(__FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
m_server->AsyncRunStep(true);
ThreadStarted();
porting::setThreadName("ServerThread");
while (!StopRequested()) {
while (!stopRequested()) {
try {
//TimeTaker timer("AsyncRunStep() + Receive()");
@ -267,8 +261,8 @@ Server::Server(
errorstream << std::endl;
}
// Lock environment
JMutexAutoLock envlock(m_env_mutex);
//lock environment
MutexAutoLock envlock(m_env_mutex);
// Load mapgen params from Settings
m_emerge->loadMapgenParams();
@ -379,7 +373,7 @@ Server::~Server()
SendChatMessage(PEER_ID_INEXISTENT, L"*** Server shutting down");
{
JMutexAutoLock envlock(m_env_mutex);
MutexAutoLock envlock(m_env_mutex);
// Execute script shutdown hooks
m_script->on_shutdown();
@ -447,14 +441,14 @@ void Server::start(Address bind_addr)
<< bind_addr.serializeString() <<"..."<<std::endl;
// Stop thread if already running
m_thread->Stop();
m_thread->stop();
// Initialize connection
m_con.SetTimeoutMs(30);
m_con.Serve(bind_addr);
// Start thread
m_thread->Start();
m_thread->start();
// ASCII art for the win!
actionstream
@ -477,9 +471,9 @@ void Server::stop()
infostream<<"Server: Stopping and waiting threads"<<std::endl;
// Stop threads (set run=false first so both start stopping)
m_thread->Stop();
m_thread->stop();
//m_emergethread.setRun(false);
m_thread->Wait();
m_thread->wait();
//m_emergethread.stop();
infostream<<"Server: Threads stopped"<<std::endl;
@ -492,7 +486,7 @@ void Server::step(float dtime)
if(dtime > 2.0)
dtime = 2.0;
{
JMutexAutoLock lock(m_step_dtime_mutex);
MutexAutoLock lock(m_step_dtime_mutex);
m_step_dtime += dtime;
}
// Throw if fatal error occurred in thread
@ -521,7 +515,7 @@ void Server::AsyncRunStep(bool initial_step)
float dtime;
{
JMutexAutoLock lock1(m_step_dtime_mutex);
MutexAutoLock lock1(m_step_dtime_mutex);
dtime = m_step_dtime;
}
@ -539,7 +533,7 @@ void Server::AsyncRunStep(bool initial_step)
//infostream<<"Server::AsyncRunStep(): dtime="<<dtime<<std::endl;
{
JMutexAutoLock lock1(m_step_dtime_mutex);
MutexAutoLock lock1(m_step_dtime_mutex);
m_step_dtime -= dtime;
}
@ -570,7 +564,7 @@ void Server::AsyncRunStep(bool initial_step)
}
{
JMutexAutoLock lock(m_env_mutex);
MutexAutoLock lock(m_env_mutex);
// Figure out and report maximum lag to environment
float max_lag = m_env->getMaxLagEstimate();
max_lag *= 0.9998; // Decrease slowly (about half per 5 minutes)
@ -590,7 +584,7 @@ void Server::AsyncRunStep(bool initial_step)
static const float map_timer_and_unload_dtime = 2.92;
if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime))
{
JMutexAutoLock lock(m_env_mutex);
MutexAutoLock lock(m_env_mutex);
// Run Map's timers and unload unused data
ScopeProfiler sp(g_profiler, "Server: map timer and unload");
m_env->getMap().timerUpdate(map_timer_and_unload_dtime,
@ -608,7 +602,7 @@ void Server::AsyncRunStep(bool initial_step)
{
m_liquid_transform_timer -= m_liquid_transform_every;
JMutexAutoLock lock(m_env_mutex);
MutexAutoLock lock(m_env_mutex);
ScopeProfiler sp(g_profiler, "Server: liquid transform");
@ -669,9 +663,9 @@ void Server::AsyncRunStep(bool initial_step)
*/
{
//infostream<<"Server: Checking added and deleted active objects"<<std::endl;
JMutexAutoLock envlock(m_env_mutex);
MutexAutoLock envlock(m_env_mutex);
m_clients.Lock();
m_clients.lock();
std::map<u16, RemoteClient*> clients = m_clients.getClientList();
ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs");
@ -792,14 +786,14 @@ void Server::AsyncRunStep(bool initial_step)
<< added_objects.size() << " added, "
<< "packet size is " << pktSize << std::endl;
}
m_clients.Unlock();
m_clients.unlock();
}
/*
Send object messages
*/
{
JMutexAutoLock envlock(m_env_mutex);
MutexAutoLock envlock(m_env_mutex);
ScopeProfiler sp(g_profiler, "Server: sending object messages");
// Key = object id
@ -825,7 +819,7 @@ void Server::AsyncRunStep(bool initial_step)
message_list->push_back(aom);
}
m_clients.Lock();
m_clients.lock();
std::map<u16, RemoteClient*> clients = m_clients.getClientList();
// Route data to every client
for (std::map<u16, RemoteClient*>::iterator
@ -876,7 +870,7 @@ void Server::AsyncRunStep(bool initial_step)
SendActiveObjectMessages(client->peer_id, unreliable_data, false);
}
}
m_clients.Unlock();
m_clients.unlock();
// Clear buffered_messages
for(std::map<u16, std::vector<ActiveObjectMessage>* >::iterator
@ -891,7 +885,7 @@ void Server::AsyncRunStep(bool initial_step)
*/
{
// We will be accessing the environment
JMutexAutoLock lock(m_env_mutex);
MutexAutoLock lock(m_env_mutex);
// Don't send too many at a time
//u32 count = 0;
@ -1012,7 +1006,7 @@ void Server::AsyncRunStep(bool initial_step)
if(counter >= g_settings->getFloat("server_map_save_interval"))
{
counter = 0.0;
JMutexAutoLock lock(m_env_mutex);
MutexAutoLock lock(m_env_mutex);
ScopeProfiler sp(g_profiler, "Server: saving stuff");
@ -1068,7 +1062,7 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id)
{
std::string playername = "";
PlayerSAO *playersao = NULL;
m_clients.Lock();
m_clients.lock();
try {
RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_InitDone);
if (client != NULL) {
@ -1076,10 +1070,10 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id)
playersao = emergePlayer(playername.c_str(), peer_id, client->net_proto_version);
}
} catch (std::exception &e) {
m_clients.Unlock();
m_clients.unlock();
throw;
}
m_clients.Unlock();
m_clients.unlock();
RemotePlayer *player =
static_cast<RemotePlayer*>(m_env->getPlayer(playername.c_str()));
@ -1174,7 +1168,7 @@ void Server::ProcessData(NetworkPacket *pkt)
{
DSTACK(__FUNCTION_NAME);
// Environment is locked first.
JMutexAutoLock envlock(m_env_mutex);
MutexAutoLock envlock(m_env_mutex);
ScopeProfiler sp(g_profiler, "Server::ProcessData");
u32 peer_id = pkt->getPeerId();
@ -1356,14 +1350,14 @@ void Server::setInventoryModified(const InventoryLocation &loc, bool playerSend)
void Server::SetBlocksNotSent(std::map<v3s16, MapBlock *>& block)
{
std::vector<u16> clients = m_clients.getClientIDs();
m_clients.Lock();
m_clients.lock();
// Set the modified blocks unsent for all the clients
for (std::vector<u16>::iterator i = clients.begin();
i != clients.end(); ++i) {
if (RemoteClient *client = m_clients.lockedGetClientNoEx(*i))
client->SetBlocksNotSent(block);
}
m_clients.Unlock();
m_clients.unlock();
}
void Server::peerAdded(con::Peer *peer)
@ -1413,11 +1407,11 @@ bool Server::getClientInfo(
)
{
*state = m_clients.getClientState(peer_id);
m_clients.Lock();
m_clients.lock();
RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_Invalid);
if (client == NULL) {
m_clients.Unlock();
m_clients.unlock();
return false;
}
@ -1430,7 +1424,7 @@ bool Server::getClientInfo(
*patch = client->getPatch();
*vers_string = client->getPatch();
m_clients.Unlock();
m_clients.unlock();
return true;
}
@ -2098,7 +2092,7 @@ void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id,
}
NetworkPacket pkt(TOCLIENT_ADDNODE, 6 + 2 + 1 + 1 + 1);
m_clients.Lock();
m_clients.lock();
RemoteClient* client = m_clients.lockedGetClientNoEx(*i);
if (client != 0) {
pkt << p << n.param0 << n.param1 << n.param2
@ -2112,7 +2106,7 @@ void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id,
}
}
}
m_clients.Unlock();
m_clients.unlock();
// Send as reliable
if (pkt.getSize() > 0)
@ -2123,13 +2117,13 @@ void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id,
void Server::setBlockNotSent(v3s16 p)
{
std::vector<u16> clients = m_clients.getClientIDs();
m_clients.Lock();
m_clients.lock();
for(std::vector<u16>::iterator i = clients.begin();
i != clients.end(); ++i) {
RemoteClient *client = m_clients.lockedGetClientNoEx(*i);
client->SetBlockNotSent(p);
}
m_clients.Unlock();
m_clients.unlock();
}
void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version)
@ -2158,7 +2152,7 @@ void Server::SendBlocks(float dtime)
{
DSTACK(__FUNCTION_NAME);
JMutexAutoLock envlock(m_env_mutex);
MutexAutoLock envlock(m_env_mutex);
//TODO check if one big lock could be faster then multiple small ones
ScopeProfiler sp(g_profiler, "Server: sel and send blocks to clients");
@ -2172,7 +2166,7 @@ void Server::SendBlocks(float dtime)
std::vector<u16> clients = m_clients.getClientIDs();
m_clients.Lock();
m_clients.lock();
for(std::vector<u16>::iterator i = clients.begin();
i != clients.end(); ++i) {
RemoteClient *client = m_clients.lockedGetClientNoEx(*i, CS_Active);
@ -2183,7 +2177,7 @@ void Server::SendBlocks(float dtime)
total_sending += client->SendingCount();
client->GetNextBlocks(m_env,m_emerge, dtime, queue);
}
m_clients.Unlock();
m_clients.unlock();
}
// Sort.
@ -2191,7 +2185,7 @@ void Server::SendBlocks(float dtime)
// Lowest is most important.
std::sort(queue.begin(), queue.end());
m_clients.Lock();
m_clients.lock();
for(u32 i=0; i<queue.size(); i++)
{
//TODO: Calculate limit dynamically
@ -2221,7 +2215,7 @@ void Server::SendBlocks(float dtime)
client->SentBlock(q.pos);
total_sending++;
}
m_clients.Unlock();
m_clients.unlock();
}
void Server::fillMediaCache()
@ -2702,7 +2696,7 @@ void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason)
}
}
{
JMutexAutoLock env_lock(m_env_mutex);
MutexAutoLock env_lock(m_env_mutex);
m_clients.DeleteClient(peer_id);
}
}

4
src/server.h
View File

@ -516,7 +516,7 @@ private:
// Environment
ServerEnvironment *m_env;
JMutex m_env_mutex;
Mutex m_env_mutex;
// server connection
con::Connection m_con;
@ -557,7 +557,7 @@ private:
// A buffer for time steps
// step() increments and AsyncRunStep() run by m_thread reads it.
float m_step_dtime;
JMutex m_step_dtime_mutex;
Mutex m_step_dtime_mutex;
// current server step lag counter
float m_lag;

36
src/settings.cpp
View File

@ -20,7 +20,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "settings.h"
#include "irrlichttypes_bloated.h"
#include "exceptions.h"
#include "jthread/jmutexautolock.h"
#include "threading/mutex_auto_lock.h"
#include "strfnd.h"
#include <iostream>
#include <fstream>
@ -56,8 +56,8 @@ Settings & Settings::operator = (const Settings &other)
if (&other == this)
return *this;
JMutexAutoLock lock(m_mutex);
JMutexAutoLock lock2(other.m_mutex);
MutexAutoLock lock(m_mutex);
MutexAutoLock lock2(other.m_mutex);
clearNoLock();
updateNoLock(other);
@ -155,7 +155,7 @@ bool Settings::readConfigFile(const char *filename)
bool Settings::parseConfigLines(std::istream &is, const std::string &end)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
std::string line, name, value;
@ -194,7 +194,7 @@ bool Settings::parseConfigLines(std::istream &is, const std::string &end)
void Settings::writeLines(std::ostream &os, u32 tab_depth) const
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
for (std::map<std::string, SettingsEntry>::const_iterator
it = m_settings.begin();
@ -298,7 +298,7 @@ bool Settings::updateConfigObject(std::istream &is, std::ostream &os,
bool Settings::updateConfigFile(const char *filename)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
std::ifstream is(filename);
std::ostringstream os(std::ios_base::binary);
@ -379,7 +379,7 @@ bool Settings::parseCommandLine(int argc, char *argv[],
const SettingsEntry &Settings::getEntry(const std::string &name) const
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
std::map<std::string, SettingsEntry>::const_iterator n;
if ((n = m_settings.find(name)) == m_settings.end()) {
@ -562,7 +562,7 @@ bool Settings::getNoiseParamsFromGroup(const std::string &name,
bool Settings::exists(const std::string &name) const
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
return (m_settings.find(name) != m_settings.end() ||
m_defaults.find(name) != m_defaults.end());
@ -742,7 +742,7 @@ bool Settings::setEntry(const std::string &name, const void *data,
return false;
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
SettingsEntry &entry = set_default ? m_defaults[name] : m_settings[name];
old_group = entry.group;
@ -878,7 +878,7 @@ bool Settings::setNoiseParams(const std::string &name,
bool Settings::remove(const std::string &name)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
delete m_settings[name].group;
return m_settings.erase(name);
@ -887,13 +887,13 @@ bool Settings::remove(const std::string &name)
void Settings::clear()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
clearNoLock();
}
void Settings::clearDefaults()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
clearDefaultsNoLock();
}
@ -902,7 +902,7 @@ void Settings::updateValue(const Settings &other, const std::string &name)
if (&other == this)
return;
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
try {
std::string val = other.get(name);
@ -918,8 +918,8 @@ void Settings::update(const Settings &other)
if (&other == this)
return;
JMutexAutoLock lock(m_mutex);
JMutexAutoLock lock2(other.m_mutex);
MutexAutoLock lock(m_mutex);
MutexAutoLock lock2(other.m_mutex);
updateNoLock(other);
}
@ -982,13 +982,13 @@ void Settings::clearDefaultsNoLock()
void Settings::registerChangedCallback(std::string name,
setting_changed_callback cbf, void *userdata)
{
JMutexAutoLock lock(m_callbackMutex);
MutexAutoLock lock(m_callbackMutex);
m_callbacks[name].push_back(std::make_pair(cbf, userdata));
}
void Settings::deregisterChangedCallback(std::string name, setting_changed_callback cbf, void *userdata)
{
JMutexAutoLock lock(m_callbackMutex);
MutexAutoLock lock(m_callbackMutex);
std::map<std::string, std::vector<std::pair<setting_changed_callback, void*> > >::iterator iterToVector = m_callbacks.find(name);
if (iterToVector != m_callbacks.end())
{
@ -1004,7 +1004,7 @@ void Settings::deregisterChangedCallback(std::string name, setting_changed_callb
void Settings::doCallbacks(const std::string name)
{
JMutexAutoLock lock(m_callbackMutex);
MutexAutoLock lock(m_callbackMutex);
std::map<std::string, std::vector<std::pair<setting_changed_callback, void*> > >::iterator iterToVector = m_callbacks.find(name);
if (iterToVector != m_callbacks.end())
{

6
src/settings.h
View File

@ -22,7 +22,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "irrlichttypes_bloated.h"
#include "util/string.h"
#include "jthread/jmutex.h"
#include "threading/mutex.h"
#include <string>
#include <map>
#include <list>
@ -225,8 +225,8 @@ private:
std::map<std::string, std::vector<std::pair<setting_changed_callback,void*> > > m_callbacks;
mutable JMutex m_callbackMutex;
mutable JMutex m_mutex; // All methods that access m_settings/m_defaults directly should lock this.
mutable Mutex m_callbackMutex;
mutable Mutex m_mutex; // All methods that access m_settings/m_defaults directly should lock this.
};

8
src/shader.cpp
View File

@ -328,7 +328,7 @@ private:
// The first position contains a dummy shader.
std::vector<ShaderInfo> m_shaderinfo_cache;
// The former container is behind this mutex
JMutex m_shaderinfo_cache_mutex;
Mutex m_shaderinfo_cache_mutex;
// Queued shader fetches (to be processed by the main thread)
RequestQueue<std::string, u32, u8, u8> m_get_shader_queue;
@ -469,7 +469,7 @@ u32 ShaderSource::getShaderIdDirect(const std::string &name,
Add shader to caches (add dummy shaders too)
*/
JMutexAutoLock lock(m_shaderinfo_cache_mutex);
MutexAutoLock lock(m_shaderinfo_cache_mutex);
u32 id = m_shaderinfo_cache.size();
m_shaderinfo_cache.push_back(info);
@ -483,7 +483,7 @@ u32 ShaderSource::getShaderIdDirect(const std::string &name,
ShaderInfo ShaderSource::getShaderInfo(u32 id)
{
JMutexAutoLock lock(m_shaderinfo_cache_mutex);
MutexAutoLock lock(m_shaderinfo_cache_mutex);
if(id >= m_shaderinfo_cache.size())
return ShaderInfo();
@ -511,7 +511,7 @@ void ShaderSource::insertSourceShader(const std::string &name_of_shader,
void ShaderSource::rebuildShaders()
{
JMutexAutoLock lock(m_shaderinfo_cache_mutex);
MutexAutoLock lock(m_shaderinfo_cache_mutex);
/*// Oh well... just clear everything, they'll load sometime.
m_shaderinfo_cache.clear();

6
src/threading/CMakeLists.txt Normal file
View File

@ -0,0 +1,6 @@
set(JTHREAD_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/mutex.cpp
${CMAKE_CURRENT_SOURCE_DIR}/thread.cpp
${CMAKE_CURRENT_SOURCE_DIR}/semaphore.cpp
PARENT_SCOPE)

96
src/threading/atomic.h Normal file
View File

@ -0,0 +1,96 @@
/*
Minetest
Copyright (C) 2015 ShadowNinja <shadowninja@minetest.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef THREADING_ATOMIC_H
#define THREADING_ATOMIC_H
#if __cplusplus >= 201103L
#include <atomic>
template<typename T> using Atomic = std::atomic<T>;
#else
#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
#if GCC_VERSION >= 407 || CLANG_VERSION >= 302
#define ATOMIC_LOAD(T, v) return __atomic_load_n(&(v), __ATOMIC_SEQ_CST)
#define ATOMIC_STORE(T, v, x) __atomic_store (&(v), &(x), __ATOMIC_SEQ_CST); return x
#define ATOMIC_ADD_EQ(T, v, x) return __atomic_add_fetch(&(v), (x), __ATOMIC_SEQ_CST)
#define ATOMIC_SUB_EQ(T, v, x) return __atomic_sub_fetch(&(v), (x), __ATOMIC_SEQ_CST)
#define ATOMIC_POST_INC(T, v) return __atomic_fetch_add(&(v), 1, __ATOMIC_SEQ_CST)
#define ATOMIC_POST_DEC(T, v) return __atomic_fetch_sub(&(v), 1, __ATOMIC_SEQ_CST)
#else
#define ATOMIC_USE_LOCK
#include "threading/mutex.h"
#define ATOMIC_LOCK_OP(T, op) do { \
mutex.lock(); \
T _val = (op); \
mutex.unlock(); \
return _val; \
} while (0)
#define ATOMIC_LOAD(T, v) \
if (sizeof(T) <= sizeof(void*)) return v; \
else ATOMIC_LOCK_OP(T, v);
#define ATOMIC_STORE(T, v, x) \
if (sizeof(T) <= sizeof(void*)) return v = x; \
else ATOMIC_LOCK_OP(T, v = x);
# if GCC_VERSION >= 401
#define ATOMIC_ADD_EQ(T, v, x) return __sync_add_and_fetch(&(v), (x))
#define ATOMIC_SUB_EQ(T, v, x) return __sync_sub_and_fetch(&(v), (x))
#define ATOMIC_POST_INC(T, v) return __sync_fetch_and_add(&(v), 1)
#define ATOMIC_POST_DEC(T, v) return __sync_fetch_and_sub(&(v), 1)
# else
#define ATOMIC_ADD_EQ(T, v, x) ATOMIC_LOCK_OP(T, v += x)
#define ATOMIC_SUB_EQ(T, v, x) ATOMIC_LOCK_OP(T, v -= x)
#define ATOMIC_POST_INC(T, v) ATOMIC_LOCK_OP(T, v++)
#define ATOMIC_POST_DEC(T, v) ATOMIC_LOCK_OP(T, v--)
# endif
#endif
template<typename T>
class Atomic
{
// Like C++11 std::enable_if, but defaults to char since C++03 doesn't support SFINAE
template<bool B, typename T_ = void> struct enable_if { typedef char type; };
template<typename T_> struct enable_if<true, T_> { typedef T_ type; };
public:
Atomic(const T &v=0) : val(v) {}
operator T () { ATOMIC_LOAD(T, val); }
T operator = (T x) { ATOMIC_STORE(T, val, x); }
T operator += (T x) { ATOMIC_ADD_EQ(T, val, x); }
T operator -= (T x) { ATOMIC_SUB_EQ(T, val, x); }
T operator ++ () { return *this += 1; }
T operator -- () { return *this -= 1; }
T operator ++ (int) { ATOMIC_POST_INC(T, val); }
T operator -- (int) { ATOMIC_POST_DEC(T, val); }
private:
volatile T val;
#ifdef ATOMIC_USE_LOCK
typename enable_if<sizeof(T) <= sizeof(void*), Mutex>::type mutex;
#endif
};
#endif // C++11
#endif

57
src/threading/event.h Normal file
View File

@ -0,0 +1,57 @@
/*
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 THREADING_EVENT_H
#define THREADING_EVENT_H
#ifdef _WIN32
#include <windows.h>
#else
#include "threading/semaphore.h"
#endif
class Event {
public:
#ifdef _WIN32
Event() { event = CreateEvent(NULL, false, false, NULL); }
~Event() { CloseHandle(event); }
void wait() { WaitForSingleObject(event, INFINITE); }
void signal() { SetEvent(event); }
#else
void wait() { sem.wait(); }
void signal() { sem.post(); }
#endif
private:
#ifdef _WIN32
HANDLE event;
#else
Semaphore sem;
#endif
};
#endif

83
src/threading/mutex.cpp Normal file
View File

@ -0,0 +1,83 @@
/*
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.
*/
// Windows std::mutex is much slower than the critical section API
#if __cplusplus < 201103L || defined(_WIN32)
#include "threading/mutex.h"
#ifndef _WIN32
#include <cassert>
#endif
#define UNUSED(expr) do { (void)(expr); } while (0)
Mutex::Mutex()
{
#ifdef _WIN32
InitializeCriticalSection(&mutex);
#else
int ret = pthread_mutex_init(&mutex, NULL);
assert(!ret);
UNUSED(ret);
#endif
}
Mutex::~Mutex()
{
#ifdef _WIN32
DeleteCriticalSection(&mutex);
#else
int ret = pthread_mutex_destroy(&mutex);
assert(!ret);
UNUSED(ret);
#endif
}
void Mutex::lock()
{
#ifdef _WIN32
EnterCriticalSection(&mutex);
#else
int ret = pthread_mutex_lock(&mutex);
assert(!ret);
UNUSED(ret);
#endif
}
void Mutex::unlock()
{
#ifdef _WIN32
LeaveCriticalSection(&mutex);
#else
int ret = pthread_mutex_unlock(&mutex);
assert(!ret);
UNUSED(ret);
#endif
}
#endif

66
src/threading/mutex.h Normal file
View File

@ -0,0 +1,66 @@
/*
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 THREADING_MUTEX_H
#define THREADING_MUTEX_H
// Windows std::mutex is much slower than the critical section API
#if __cplusplus >= 201103L && !defined(_WIN32)
#include <mutex>
using Mutex = std::mutex;
#else
#ifdef _WIN32
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#else // pthread
#include <pthread.h>
#endif
class Mutex
{
public:
Mutex();
~Mutex();
void lock();
void unlock();
private:
#ifdef _WIN32
CRITICAL_SECTION mutex;
#else // pthread
pthread_mutex_t mutex;
#endif
};
#endif // C++11
#endif

44
src/jthread/LICENSE.MIT → src/threading/mutex_auto_lock.h
View File

@ -1,4 +1,8 @@
The license of JThread:
/*
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"),
@ -7,14 +11,40 @@ 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 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,
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.
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#ifndef THREADING_MUTEX_AUTO_LOCK_H
#define THREADING_MUTEX_AUTO_LOCK_H
#if __cplusplus >= 201103L
#include <mutex>
using MutexAutoLock = std::lock_guard<std::mutex>;
#else
#include "threading/mutex.h"
class MutexAutoLock
{
public:
MutexAutoLock(Mutex &m) : mutex(m) { mutex.lock(); }
~MutexAutoLock() { mutex.unlock(); }
private:
Mutex &mutex;
};
#endif
#endif

161
src/threading/semaphore.cpp Normal file
View File

@ -0,0 +1,161 @@
/*
Minetest
Copyright (C) 2013 sapier <sapier AT gmx DOT net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "threading/semaphore.h"
#include <iostream>
#include <cstdlib>
#include <cassert>
#define UNUSED(expr) do { (void)(expr); } while (0)
#ifdef _WIN32
#define MAX_SEMAPHORE_COUNT LONG_MAX - 1
#else
#include <cerrno>
#include <sys/time.h>
#include <pthread.h>
#if defined(__MACH__) && defined(__APPLE__)
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/semaphore.h>
#include <sys/semaphore.h>
#include <unistd.h>
#undef sem_t
#undef sem_init
#undef sem_wait
#undef sem_post
#undef sem_destroy
#define sem_t semaphore_t
#define sem_init(s, p, c) semaphore_create(mach_task_self(), (s), 0, (c))
#define sem_wait(s) semaphore_wait(*(s))
#define sem_post(s) semaphore_signal(*(s))
#define sem_destroy(s) semaphore_destroy(mach_task_self(), *(s))
#endif
#endif
Semaphore::Semaphore(int val)
{
#ifdef _WIN32
semaphore = CreateSemaphore(NULL, val, MAX_SEMAPHORE_COUNT, NULL);
#else
int ret = sem_init(&semaphore, 0, val);
assert(!ret);
UNUSED(ret);
#endif
}
Semaphore::~Semaphore()
{
#ifdef _WIN32
CloseHandle(semaphore);
#else
int ret = sem_destroy(&semaphore);
#ifdef __ANDROID__
// Workaround for broken bionic semaphore implementation!
assert(!ret || errno == EBUSY);
#else
assert(!ret);
#endif
UNUSED(ret);
#endif
}
void Semaphore::post(unsigned int num)
{
assert(num > 0);
#ifdef _WIN32
ReleaseSemaphore(semaphore, num, NULL);
#else
for (unsigned i = 0; i < num; i++) {
int ret = sem_post(&semaphore);
assert(!ret);
UNUSED(ret);
}
#endif
}
void Semaphore::wait()
{
#ifdef _WIN32
WaitForSingleObject(semaphore, INFINITE);
#else
int ret = sem_wait(&semaphore);
assert(!ret);
UNUSED(ret);
#endif
}
bool Semaphore::wait(unsigned int time_ms)
{
#ifdef _WIN32
unsigned int ret = WaitForSingleObject(semaphore, time_ms);
if (ret == WAIT_OBJECT_0) {
return true;
} else {
assert(ret == WAIT_TIMEOUT);
return false;
}
#else
# if defined(__MACH__) && defined(__APPLE__)
mach_timespec_t wait_time;
wait_time.tv_sec = time_ms / 1000;
wait_time.tv_nsec = 1000000 * (time_ms % 1000);
errno = 0;
int ret = semaphore_timedwait(semaphore, wait_time);
switch (ret) {
case KERN_OPERATION_TIMED_OUT:
errno = ETIMEDOUT;
break;
case KERN_ABORTED:
errno = EINTR;
break;
default:
if (ret)
errno = EINVAL;
}
# else
struct timespec wait_time;
struct timeval now;
if (gettimeofday(&now, NULL) == -1) {
std::cerr << "Semaphore::wait(ms): Unable to get time with gettimeofday!" << std::endl;
abort();
}
wait_time.tv_nsec = ((time_ms % 1000) * 1000 * 1000) + (now.tv_usec * 1000);
wait_time.tv_sec = (time_ms / 1000) + (wait_time.tv_nsec / (1000 * 1000 * 1000)) + now.tv_sec;
wait_time.tv_nsec %= 1000 * 1000 * 1000;
int ret = sem_timedwait(&semaphore, &wait_time);
# endif
assert(!ret || (errno == ETIMEDOUT || errno == EINTR));
return !ret;
#endif
}

42
src/jthread/jsemaphore.h → src/threading/semaphore.h
View File

@ -1,6 +1,6 @@
/*
Minetest
Copyright (C) 2013 sapier, < sapier AT gmx DOT net >
Copyright (C) 2013 sapier <sapier AT gmx DOT net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
@ -17,48 +17,36 @@ with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef JSEMAPHORE_H_
#define JSEMAPHORE_H_
#ifndef THREADING_SEMAPHORE_H
#define THREADING_SEMAPHORE_H
#if defined(WIN32)
#if defined(_WIN32)
#include <windows.h>
#include <assert.h>
#define MAX_SEMAPHORE_COUNT 1024
#elif defined(__MACH__) && defined(__APPLE__)
#include <pthread.h>
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/semaphore.h>
#include <sys/semaphore.h>
#include <errno.h>
#include <time.h>
#else
#include <pthread.h>
#include <semaphore.h>
#endif
class JSemaphore {
class Semaphore {
public:
JSemaphore();
~JSemaphore();
JSemaphore(int initval);
Semaphore(int val=0);
~Semaphore();
void Post();
void Wait();
bool Wait(unsigned int time_ms);
int GetValue();
void post(unsigned int num=1);
void wait();
bool wait(unsigned int time_ms);
private:
#if defined(WIN32)
HANDLE m_hSemaphore;
HANDLE semaphore;
#elif defined(__MACH__) && defined(__APPLE__)
semaphore_t m_semaphore;
int semcount;
semaphore_t semaphore;
#else
sem_t m_semaphore;
sem_t semaphore;
#endif
};
#endif
#endif /* JSEMAPHORE_H_ */

354
src/threading/thread.cpp Normal file
View File

@ -0,0 +1,354 @@
/*
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 "threading/thread.h"
#include "threading/mutex_auto_lock.h"
#include "log.h"
#if __cplusplus >= 201103L
#include <chrono>
#else
#define UNUSED(expr) do { (void)(expr); } while (0)
# ifdef _WIN32
# ifndef _WIN32_WCE
#include <process.h>
# endif
# else
#include <ctime>
#include <cassert>
#include <cstdlib>
#include <sys/time.h>
// For getNumberOfProcessors
#include <unistd.h>
# if defined(__FreeBSD__) || defined(__APPLE__)
#include <sys/types.h>
#include <sys/sysctl.h>
# elif defined(_GNU_SOURCE)
#include <sys/sysinfo.h>
# endif
# endif
#endif
// For setName
#if defined(linux) || defined(__linux)
#include <sys/prctl.h>
#elif defined(__FreeBSD__) || defined(__OpenBSD__)
#include <pthread_np.h>
#elif defined(_MSC_VER)
struct THREADNAME_INFO {
DWORD dwType; // Must be 0x1000
LPCSTR szName; // Pointer to name (in user addr space)
DWORD dwThreadID; // Thread ID (-1=caller thread)
DWORD dwFlags; // Reserved for future use, must be zero
};
#endif
// For bindToProcessor
#if __FreeBSD_version >= 702106
typedef cpuset_t cpu_set_t;
#elif defined(__linux) || defined(linux)
#include <sched.h>
#elif defined(__sun) || defined(sun)
#include <sys/types.h>
#include <sys/processor.h>
#include <sys/procset.h>
#elif defined(_AIX)
#include <sys/processor.h>
#elif defined(__APPLE__)
#include <mach/mach_init.h>
#include <mach/thread_policy.h>
#endif
Thread::Thread(const std::string &name) :
name(name),
retval(NULL),
request_stop(false),
running(false)
#if __cplusplus >= 201103L
, thread(NULL)
#elif !defined(_WIN32)
, started(false)
#endif
{}
void Thread::wait()
{
#if __cplusplus >= 201103L
if (!thread || !thread->joinable())
return;
thread->join();
#elif defined(_WIN32)
if (!running)
return;
WaitForSingleObject(thread, INFINITE);
#else // pthread
void *status;
if (!started)
return;
int ret = pthread_join(thread, &status);
assert(!ret);
UNUSED(ret);
started = false;
#endif
}
bool Thread::start()
{
if (running)
return false;
request_stop = false;
#if __cplusplus >= 201103L
MutexAutoLock l(continue_mutex);
thread = new std::thread(theThread, this);
#elif defined(_WIN32)
MutexAutoLock l(continue_mutex);
# ifdef _WIN32_WCE
thread = CreateThread(NULL, 0, theThread, this, 0, &thread_id);
# else
thread = (HANDLE)_beginthreadex(NULL, 0, theThread, this, 0, &thread_id);
# endif
if (!thread)
return false;
#else
int status;
MutexAutoLock l(continue_mutex);
status = pthread_create(&thread, NULL, theThread, this);
if (status)
return false;
#endif
#if __cplusplus < 201103L
// Wait until running
while (!running) {
# ifdef _WIN32
Sleep(1);
}
# else
struct timespec req, rem;
req.tv_sec = 0;
req.tv_nsec = 1000000;
nanosleep(&req, &rem);
}
started = true;
# endif
#endif
return true;
}
bool Thread::kill()
{
#ifdef _WIN32
if (!running)
return false;
TerminateThread(getThreadHandle(), 0);
CloseHandle(getThreadHandle());
#else
if (!running) {
wait();
return false;
}
# ifdef __ANDROID__
pthread_kill(getThreadHandle(), SIGKILL);
# else
pthread_cancel(getThreadHandle());
# endif
wait();
#endif
#if __cplusplus >= 201103L
delete thread;
#endif
running = false;
return true;
}
bool Thread::isSameThread()
{
#if __cplusplus >= 201103L
return thread->get_id() == std::this_thread::get_id();
#elif defined(_WIN32)
return GetCurrentThreadId() == thread_id;
#else
return pthread_equal(pthread_self(), thread);
#endif
}
#if __cplusplus >= 201103L
void Thread::theThread(Thread *th)
#elif defined(_WIN32_WCE)
DWORD WINAPI Thread::theThread(void *param)
#elif defined(_WIN32)
UINT __stdcall Thread::theThread(void *param)
#else
void *Thread::theThread(void *param)
#endif
{
#if __cplusplus < 201103L
Thread *th = static_cast<Thread *>(param);
#endif
th->running = true;
th->setName();
log_register_thread(th->name);
th->retval = th->run();
log_deregister_thread();
th->running = false;
#if __cplusplus < 201103L
# ifdef _WIN32
CloseHandle(th->thread);
# endif
return NULL;
#endif
}
void Thread::setName(const std::string &name)
{
#if defined(linux) || defined(__linux)
/* It would be cleaner to do this with pthread_setname_np,
* which was added to glibc in version 2.12, but some major
* distributions are still runing 2.11 and previous versions.
*/
prctl(PR_SET_NAME, name.c_str());
#elif defined(__FreeBSD__) || defined(__OpenBSD__)
pthread_set_name_np(pthread_self(), name.c_str());
#elif defined(__NetBSD__)
pthread_setname_np(pthread_self(), name.c_str());
#elif defined(__APPLE__)
pthread_setname_np(name.c_str());
#elif defined(_MSC_VER)
// Windows itself doesn't support thread names,
// but the MSVC debugger does...
THREADNAME_INFO info;
info.dwType = 0x1000;
info.szName = name.c_str();
info.dwThreadID = -1;
info.dwFlags = 0;
__try {
RaiseException(0x406D1388, 0, sizeof(info) / sizeof(DWORD), (ULONG_PTR *)&info);
} __except (EXCEPTION_CONTINUE_EXECUTION) {
}
#elif defined(_WIN32) || defined(__GNU__)
// These platforms are known to not support thread names.
// Silently ignore the request.
#else
#warning "Unrecognized platform, thread names will not be available."
#endif
}
unsigned int Thread::getNumberOfProcessors()
{
#if __cplusplus >= 201103L
return std::thread::hardware_concurrency();
#elif defined(_SC_NPROCESSORS_ONLN)
return sysconf(_SC_NPROCESSORS_ONLN);
#elif defined(__FreeBSD__) || defined(__APPLE__)
unsigned int len, count;
len = sizeof(count);
return sysctlbyname("hw.ncpu", &count, &len, NULL, 0);
#elif defined(_GNU_SOURCE)
return get_nprocs();
#elif defined(_WIN32)
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
return sysinfo.dwNumberOfProcessors;
#elif defined(PTW32_VERSION) || defined(__hpux)
return pthread_num_processors_np();
#else
return 1;
#endif
}
bool Thread::bindToProcessor(unsigned int num)
{
#if defined(__ANDROID__)
return false;
#elif defined(_WIN32)
return SetThreadAffinityMask(getThreadHandle(), 1 << num);
#elif __FreeBSD_version >= 702106 || defined(__linux) || defined(linux)
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(num, &cpuset);
return pthread_setaffinity_np(getThreadHandle(), sizeof(cpuset),
&cpuset) == 0;
#elif defined(__sun) || defined(sun)
return processor_bind(P_LWPID, MAKE_LWPID_PTHREAD(getThreadHandle()),
num, NULL) == 0
#elif defined(_AIX)
return bindprocessor(BINDTHREAD, (tid_t) getThreadHandle(), pnumber) == 0;
#elif defined(__hpux) || defined(hpux)
pthread_spu_t answer;
return pthread_processor_bind_np(PTHREAD_BIND_ADVISORY_NP,
&answer, num, getThreadHandle()) == 0;
#elif defined(__APPLE__)
struct thread_affinity_policy tapol;
thread_port_t threadport = pthread_mach_thread_np(getThreadHandle());
tapol.affinity_tag = num + 1;
return thread_policy_set(threadport, THREAD_AFFINITY_POLICY,
(thread_policy_t)&tapol,
THREAD_AFFINITY_POLICY_COUNT) == KERN_SUCCESS;
#else
return false;
#endif
}
bool Thread::setPriority(int prio)
{
#if defined(_WIN32)
return SetThreadPriority(getThreadHandle(), prio);
#else
struct sched_param sparam;
int policy;
if (pthread_getschedparam(getThreadHandle(), &policy, &sparam) != 0)
return false;
int min = sched_get_priority_min(policy);
int max = sched_get_priority_max(policy);
sparam.sched_priority = min + prio * (max - min) / THREAD_PRIORITY_HIGHEST;
return pthread_setschedparam(getThreadHandle(), policy, &sparam) == 0;
#endif
}

119
src/threading/thread.h Normal file
View File

@ -0,0 +1,119 @@
/*
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 THREADING_THREAD_H
#define THREADING_THREAD_H
#include "threading/atomic.h"
#include "threading/mutex.h"
#include <string>
#if __cplusplus >= 201103L
#include <thread>
#endif
#ifndef _WIN32
enum {
THREAD_PRIORITY_LOWEST,
THREAD_PRIORITY_BELOW_NORMAL,
THREAD_PRIORITY_NORMAL,
THREAD_PRIORITY_ABOVE_NORMAL,
THREAD_PRIORITY_HIGHEST,
};
#endif
class Thread
{
public:
Thread(const std::string &name="Unnamed");
virtual ~Thread() { kill(); }
bool start();
inline void stop() { request_stop = true; }
bool kill();
inline bool isRunning() { return running; }
inline bool stopRequested() { return request_stop; }
void *getReturnValue() { return running ? NULL : retval; }
bool isSameThread();
static unsigned int getNumberOfProcessors();
bool bindToProcessor(unsigned int);
bool setPriority(int);
/*
* Wait for thread to finish.
* Note: this does not stop a thread, you have to do this on your own.
* Returns immediately if the thread is not started.
*/
void wait();
static void setName(const std::string &name);
protected:
std::string name;
virtual void *run() = 0;
private:
void setName() { setName(name); }
void *retval;
Atomic<bool> request_stop;
Atomic<bool> running;
Mutex continue_mutex;
#if __cplusplus >= 201103L
static void theThread(Thread *th);
std::thread *thread;
std::thread::native_handle_type getThreadHandle() const
{ return thread->native_handle(); }
#else
# if defined(WIN32) || defined(_WIN32_WCE)
# ifdef _WIN32_WCE
DWORD thread_id;
static DWORD WINAPI theThread(void *param);
# else
UINT thread_id;
static UINT __stdcall theThread(void *param);
# endif
HANDLE thread;
HANDLE getThreadHandle() const { return thread; }
# else // pthread
static void *theThread(void *param);
pthread_t thread;
pthread_t getThreadHandle() const { return thread; }
Atomic<bool> started;
# endif
#endif
};
#endif

6
src/threads.h
View File

@ -20,9 +20,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#ifndef THREADS_HEADER
#define THREADS_HEADER
#include "jthread/jmutex.h"
#include "threading/mutex.h"
#if (defined(WIN32) || defined(_WIN32_WCE))
#if defined(WIN32) || defined(_WIN32_WCE)
typedef DWORD threadid_t;
#else
typedef pthread_t threadid_t;
@ -30,7 +30,7 @@ typedef pthread_t threadid_t;
inline threadid_t get_current_thread_id()
{
#if (defined(WIN32) || defined(_WIN32_WCE))
#if defined(WIN32) || defined(_WIN32_WCE)
return GetCurrentThreadId();
#else
return pthread_self();

1
src/unittest/CMakeLists.txt
View File

@ -17,6 +17,7 @@ set (UNITTEST_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/test_serialization.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_settings.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_socket.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_threading.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_utilities.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_voxelalgorithms.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_voxelmanipulator.cpp

85
src/unittest/test_threading.cpp Normal file
View File

@ -0,0 +1,85 @@
/*
Minetest
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "test.h"
#include "threading/atomic.h"
#include "threading/semaphore.h"
#include "threading/thread.h"
class TestThreading : public TestBase {
public:
TestThreading() { TestManager::registerTestModule(this); }
const char *getName() { return "TestThreading"; }
void runTests(IGameDef *);
void testAtomicSemaphoreThread();
};
static TestThreading g_test_instance;
void TestThreading::runTests(IGameDef *)
{
TEST(testAtomicSemaphoreThread);
}
class AtomicTestThread : public Thread
{
public:
AtomicTestThread(Atomic<u32> &v, Semaphore &trigger) :
Thread("AtomicTest"),
val(v),
trigger(trigger)
{}
private:
void *run()
{
trigger.wait();
for (u32 i = 0; i < 0x10000; ++i)
++val;
return NULL;
}
Atomic<u32> &val;
Semaphore &trigger;
};
void TestThreading::testAtomicSemaphoreThread()
{
Atomic<u32> val;
Semaphore trigger;
static const u8 num_threads = 4;
AtomicTestThread *threads[num_threads];
for (u8 i = 0; i < num_threads; ++i) {
threads[i] = new AtomicTestThread(val, trigger);
UASSERT(threads[i]->start());
}
trigger.post(num_threads);
for (u8 i = 0; i < num_threads; ++i) {
threads[i]->wait();
delete threads[i];
}
UASSERT(val == num_threads * 0x10000);
}

169
src/util/container.h
View File

@ -22,9 +22,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "../irrlichttypes.h"
#include "../exceptions.h"
#include "../jthread/jmutex.h"
#include "../jthread/jmutexautolock.h"
#include "../jthread/jsemaphore.h"
#include "../threading/mutex.h"
#include "../threading/mutex_auto_lock.h"
#include "../threading/semaphore.h"
#include <list>
#include <vector>
#include <map>
@ -81,111 +81,47 @@ template<typename Key, typename Value>
class MutexedMap
{
public:
MutexedMap()
{
}
MutexedMap() {}
void set(const Key &name, const Value &value)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
m_values[name] = value;
}
bool get(const Key &name, Value *result)
bool get(const Key &name, Value *result) const
{
JMutexAutoLock lock(m_mutex);
typename std::map<Key, Value>::iterator n;
n = m_values.find(name);
MutexAutoLock lock(m_mutex);
typename std::map<Key, Value>::const_iterator n =
m_values.find(name);
if (n == m_values.end())
return false;
if(result != NULL)
if (result)
*result = n->second;
return true;
}
std::vector<Value> getValues()
std::vector<Value> getValues() const
{
MutexAutoLock lock(m_mutex);
std::vector<Value> result;
for(typename std::map<Key, Value>::iterator
i = m_values.begin();
i != m_values.end(); ++i){
result.push_back(i->second);
for (typename std::map<Key, Value>::const_iterator
it = m_values.begin();
it != m_values.end(); ++it){
result.push_back(it->second);
}
return result;
}
void clear ()
{
m_values.clear();
}
void clear() { m_values.clear(); }
private:
std::map<Key, Value> m_values;
JMutex m_mutex;
mutable Mutex m_mutex;
};
/*
Generates ids for comparable values.
Id=0 is reserved for "no value".
Is fast at:
- Returning value by id (very fast)
- Returning id by value
- Generating a new id for a value
Is not able to:
- Remove an id/value pair (is possible to implement but slow)
*/
template<typename T>
class MutexedIdGenerator
{
public:
MutexedIdGenerator()
{
}
// Returns true if found
bool getValue(u32 id, T &value)
{
if(id == 0)
return false;
JMutexAutoLock lock(m_mutex);
if(m_id_to_value.size() < id)
return false;
value = m_id_to_value[id-1];
return true;
}
// If id exists for value, returns the id.
// Otherwise generates an id for the value.
u32 getId(const T &value)
{
JMutexAutoLock lock(m_mutex);
typename std::map<T, u32>::iterator n;
n = m_value_to_id.find(value);
if(n != m_value_to_id.end())
return n->second;
m_id_to_value.push_back(value);
u32 new_id = m_id_to_value.size();
m_value_to_id.insert(value, new_id);
return new_id;
}
private:
JMutex m_mutex;
// Values are stored here at id-1 position (id 1 = [0])
std::vector<T> m_id_to_value;
std::map<T, u32> m_value_to_id;
};
/*
Thread-safe FIFO queue (well, actually a FILO also)
*/
// Thread-safe Double-ended queue
template<typename T>
class MutexedQueue
@ -194,19 +130,18 @@ public:
template<typename Key, typename U, typename Caller, typename CallerData>
friend class RequestQueue;
MutexedQueue()
MutexedQueue() {}
bool empty() const
{
MutexAutoLock lock(m_mutex);
return m_queue.empty();
}
bool empty()
{
JMutexAutoLock lock(m_mutex);
return (m_queue.size() == 0);
}
void push_back(T t)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
m_queue.push_back(t);
m_size.Post();
m_signal.post();
}
/* this version of pop_front returns a empty element of T on timeout.
@ -214,37 +149,35 @@ public:
*/
T pop_frontNoEx(u32 wait_time_max_ms)
{
if (m_size.Wait(wait_time_max_ms)) {
JMutexAutoLock lock(m_mutex);
if (m_signal.wait(wait_time_max_ms)) {
MutexAutoLock lock(m_mutex);
T t = m_queue.front();
m_queue.pop_front();
return t;
}
else {
} else {
return T();
}
}
T pop_front(u32 wait_time_max_ms)
{
if (m_size.Wait(wait_time_max_ms)) {
JMutexAutoLock lock(m_mutex);
if (m_signal.wait(wait_time_max_ms)) {
MutexAutoLock lock(m_mutex);
T t = m_queue.front();
m_queue.pop_front();
return t;
}
else {
} else {
throw ItemNotFoundException("MutexedQueue: queue is empty");
}
}
T pop_frontNoEx()
{
m_size.Wait();
m_signal.wait();
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
T t = m_queue.front();
m_queue.pop_front();
@ -253,14 +186,13 @@ public:
T pop_back(u32 wait_time_max_ms=0)
{
if (m_size.Wait(wait_time_max_ms)) {
JMutexAutoLock lock(m_mutex);
if (m_signal.wait(wait_time_max_ms)) {
MutexAutoLock lock(m_mutex);
T t = m_queue.back();
m_queue.pop_back();
return t;
}
else {
} else {
throw ItemNotFoundException("MutexedQueue: queue is empty");
}
}
@ -268,25 +200,24 @@ public:
/* this version of pop_back returns a empty element of T on timeout.
* Make sure default constructor of T creates a recognizable "empty" element
*/
T pop_backNoEx(u32 wait_time_max_ms=0)
T pop_backNoEx(u32 wait_time_max_ms)
{
if (m_size.Wait(wait_time_max_ms)) {
JMutexAutoLock lock(m_mutex);
if (m_signal.wait(wait_time_max_ms)) {
MutexAutoLock lock(m_mutex);
T t = m_queue.back();
m_queue.pop_back();
return t;
}
else {
} else {
return T();
}
}
T pop_backNoEx()
{
m_size.Wait();
m_signal.wait();
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
T t = m_queue.back();
m_queue.pop_back();
@ -294,19 +225,13 @@ public:
}
protected:
JMutex & getMutex()
{
return m_mutex;
}
Mutex &getMutex() { return m_mutex; }
std::deque<T> & getQueue()
{
return m_queue;
}
std::deque<T> &getQueue() { return m_queue; }
std::deque<T> m_queue;
JMutex m_mutex;
JSemaphore m_size;
mutable Mutex m_mutex;
Semaphore m_signal;
};
template<typename K, typename V>

6
src/util/numeric.cpp
View File

@ -23,17 +23,17 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "log.h"
#include "../constants.h" // BS, MAP_BLOCKSIZE
#include "../noise.h" // PseudoRandom, PcgRandom
#include "../jthread/jmutexautolock.h"
#include "../threading/mutex_auto_lock.h"
#include <string.h>
#include <iostream>
std::map<u16, std::vector<v3s16> > FacePositionCache::m_cache;
JMutex FacePositionCache::m_cache_mutex;
Mutex FacePositionCache::m_cache_mutex;
// Calculate the borders of a "d-radius" cube
// TODO: Make it work without mutex and data races, probably thread-local
std::vector<v3s16> FacePositionCache::getFacePositions(u16 d)
{
JMutexAutoLock cachelock(m_cache_mutex);
MutexAutoLock cachelock(m_cache_mutex);
if (m_cache.find(d) != m_cache.end())
return m_cache[d];

4
src/util/numeric.h
View File

@ -24,7 +24,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "../irr_v2d.h"
#include "../irr_v3d.h"
#include "../irr_aabb3d.h"
#include "../jthread/jmutex.h"
#include "../threading/mutex.h"
#include <list>
#include <map>
#include <vector>
@ -42,7 +42,7 @@ public:
private:
static void generateFacePosition(u16 d);
static std::map<u16, std::vector<v3s16> > m_cache;
static JMutex m_cache_mutex;
static Mutex m_cache_mutex;
};
class IndentationRaiser

60
src/util/thread.h
View File

@ -21,9 +21,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#define UTIL_THREAD_HEADER
#include "../irrlichttypes.h"
#include "../jthread/jthread.h"
#include "../jthread/jmutex.h"
#include "../jthread/jmutexautolock.h"
#include "../threading/thread.h"
#include "../threading/mutex.h"
#include "../threading/mutex_auto_lock.h"
#include "porting.h"
#include "log.h"
@ -36,27 +36,27 @@ public:
T get()
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
return m_value;
}
void set(T value)
{
JMutexAutoLock lock(m_mutex);
MutexAutoLock lock(m_mutex);
m_value = value;
}
// You'll want to grab this in a SharedPtr
JMutexAutoLock *getLock()
MutexAutoLock *getLock()
{
return new JMutexAutoLock(m_mutex);
return new MutexAutoLock(m_mutex);
}
// You pretty surely want to grab the lock when accessing this
T m_value;
private:
JMutex m_mutex;
Mutex m_mutex;
};
/*
@ -118,7 +118,7 @@ public:
typename std::list<CallerInfo<Caller, CallerData, Key, T> >::iterator j;
{
JMutexAutoLock lock(m_queue.getMutex());
MutexAutoLock lock(m_queue.getMutex());
/*
If the caller is already on the list, only update CallerData
@ -192,44 +192,33 @@ private:
MutexedQueue<GetRequest<Key, T, Caller, CallerData> > m_queue;
};
class UpdateThread : public JThread {
class UpdateThread : public Thread
{
public:
UpdateThread() {}
virtual ~UpdateThread() {}
UpdateThread(const std::string &name) : Thread(name + "Update") {}
~UpdateThread() {}
void deferUpdate()
{
m_update_sem.Post();
}
void deferUpdate() { m_update_sem.post(); }
void Stop()
void stop()
{
JThread::Stop();
Thread::stop();
// give us a nudge
m_update_sem.Post();
m_update_sem.post();
}
void *Thread()
void *run()
{
ThreadStarted();
const char *thread_name = getName();
log_register_thread(thread_name);
porting::setThreadName(thread_name);
DSTACK(__FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
while (!StopRequested()) {
m_update_sem.Wait();
while (!stopRequested()) {
m_update_sem.wait();
// Set semaphore to 0
while (m_update_sem.wait(0));
// Empty the queue, just in case doUpdate() is expensive
while (m_update_sem.GetValue())
m_update_sem.Wait();
if (StopRequested())
break;
if (stopRequested()) break;
doUpdate();
}
@ -241,10 +230,9 @@ public:
protected:
virtual void doUpdate() = 0;
virtual const char *getName() = 0;
private:
JSemaphore m_update_sem;
Semaphore m_update_sem;
};
#endif