summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
-rw-r--r--scripts/src/osd/osdmini.lua1
-rw-r--r--src/emu/debug/debugvw.cpp22
-rw-r--r--src/emu/debug/dvstate.cpp18
-rw-r--r--src/emu/emualloc.cpp29
-rw-r--r--src/emu/emualloc.h3
-rw-r--r--src/emu/luaengine.cpp49
-rw-r--r--src/emu/render.cpp4
-rw-r--r--src/emu/render.h7
-rw-r--r--src/emu/ui/filemngr.cpp4
-rw-r--r--src/emu/ui/imgcntrl.cpp14
-rw-r--r--src/emu/ui/inputmap.cpp2
-rw-r--r--src/emu/ui/mainmenu.cpp44
-rw-r--r--src/emu/ui/menu.cpp14
-rw-r--r--src/emu/ui/selgame.cpp8
-rw-r--r--src/emu/ui/sliders.cpp2
-rw-r--r--src/emu/ui/slotopt.cpp2
-rw-r--r--src/emu/ui/swlist.cpp2
-rw-r--r--src/emu/ui/videoopt.cpp2
-rw-r--r--src/mame/includes/chihiro.h5
-rw-r--r--src/mame/video/chihiro.cpp3
-rw-r--r--src/osd/modules/sound/xaudio2_sound.cpp40
-rw-r--r--src/osd/modules/sync/osdsync.h16
-rw-r--r--src/osd/modules/sync/sync_mini.cpp57
-rw-r--r--src/osd/modules/sync/sync_ntc.cpp279
-rw-r--r--src/osd/modules/sync/sync_os2.cpp280
-rw-r--r--src/osd/modules/sync/sync_sdl.cpp132
-rw-r--r--src/osd/modules/sync/sync_tc.cpp117
-rw-r--r--src/osd/modules/sync/sync_windows.cpp177
-rw-r--r--src/osd/modules/sync/work_osd.cpp43
-rw-r--r--src/osd/osdcore.h87
-rw-r--r--src/osd/osdmini/minisync.cpp66
-rw-r--r--src/osd/sdl/input.cpp16
-rw-r--r--src/osd/windows/input.cpp32
-rw-r--r--src/osd/windows/window.cpp18
-rw-r--r--src/osd/windows/window.h3
35 files changed, 152 insertions, 1446 deletions
diff --git a/scripts/src/osd/osdmini.lua b/scripts/src/osd/osdmini.lua
index 0795ccdb4bd..b05839e7873 100644
--- a/scripts/src/osd/osdmini.lua
+++ b/scripts/src/osd/osdmini.lua
@@ -125,7 +125,6 @@ project ("ocore_" .. _OPTIONS["osd"])
MAME_DIR .. "src/osd/osdmini/minidir.cpp",
MAME_DIR .. "src/osd/osdmini/minifile.cpp",
MAME_DIR .. "src/osd/osdmini/minimisc.cpp",
- MAME_DIR .. "src/osd/osdmini/minisync.cpp",
MAME_DIR .. "src/osd/osdmini/minitime.cpp",
MAME_DIR .. "src/osd/modules/sync/work_mini.cpp",
}
diff --git a/src/emu/debug/debugvw.cpp b/src/emu/debug/debugvw.cpp
index eea867f3a63..0fcf1f4b2fd 100644
--- a/src/emu/debug/debugvw.cpp
+++ b/src/emu/debug/debugvw.cpp
@@ -331,7 +331,7 @@ debug_view_manager::~debug_view_manager()
{
debug_view *oldhead = m_viewlist;
m_viewlist = oldhead->m_next;
- auto_free(machine(), oldhead);
+ global_free(oldhead);
}
}
@@ -345,31 +345,31 @@ debug_view *debug_view_manager::alloc_view(debug_view_type type, debug_view_osd_
switch (type)
{
case DVT_CONSOLE:
- return append(auto_alloc(machine(), debug_view_console(machine(), osdupdate, osdprivate)));
+ return append(global_alloc(debug_view_console(machine(), osdupdate, osdprivate)));
case DVT_STATE:
- return append(auto_alloc(machine(), debug_view_state(machine(), osdupdate, osdprivate)));
+ return append(global_alloc(debug_view_state(machine(), osdupdate, osdprivate)));
case DVT_DISASSEMBLY:
- return append(auto_alloc(machine(), debug_view_disasm(machine(), osdupdate, osdprivate)));
+ return append(global_alloc(debug_view_disasm(machine(), osdupdate, osdprivate)));
case DVT_MEMORY:
- return append(auto_alloc(machine(), debug_view_memory(machine(), osdupdate, osdprivate)));
+ return append(global_alloc(debug_view_memory(machine(), osdupdate, osdprivate)));
case DVT_LOG:
- return append(auto_alloc(machine(), debug_view_log(machine(), osdupdate, osdprivate)));
+ return append(global_alloc(debug_view_log(machine(), osdupdate, osdprivate)));
case DVT_TIMERS:
-// return append(auto_alloc(machine(), debug_view_timers(machine(), osdupdate, osdprivate)));
+// return append(global_alloc(debug_view_timers(machine(), osdupdate, osdprivate)));
case DVT_ALLOCS:
-// return append(auto_alloc(machine(), debug_view_allocs(machine(), osdupdate, osdprivate)));
+// return append(global_alloc(debug_view_allocs(machine(), osdupdate, osdprivate)));
case DVT_BREAK_POINTS:
- return append(auto_alloc(machine(), debug_view_breakpoints(machine(), osdupdate, osdprivate)));
+ return append(global_alloc(debug_view_breakpoints(machine(), osdupdate, osdprivate)));
case DVT_WATCH_POINTS:
- return append(auto_alloc(machine(), debug_view_watchpoints(machine(), osdupdate, osdprivate)));
+ return append(global_alloc(debug_view_watchpoints(machine(), osdupdate, osdprivate)));
default:
fatalerror("Attempt to create invalid debug view type %d\n", type);
@@ -389,7 +389,7 @@ void debug_view_manager::free_view(debug_view &view)
if (*viewptr == &view)
{
*viewptr = view.m_next;
- auto_free(machine(), &view);
+ global_free(&view);
break;
}
}
diff --git a/src/emu/debug/dvstate.cpp b/src/emu/debug/dvstate.cpp
index 578b423725d..d0d741ed21e 100644
--- a/src/emu/debug/dvstate.cpp
+++ b/src/emu/debug/dvstate.cpp
@@ -98,7 +98,7 @@ void debug_view_state::reset()
{
state_item *oldhead = m_state_list;
m_state_list = oldhead->m_next;
- auto_free(machine(), oldhead);
+ global_free(oldhead);
}
}
@@ -117,39 +117,39 @@ void debug_view_state::recompute()
// add a cycles entry: cycles:99999999
state_item **tailptr = &m_state_list;
- *tailptr = auto_alloc(machine(), state_item(REG_CYCLES, "cycles", 8));
+ *tailptr = global_alloc(state_item(REG_CYCLES, "cycles", 8));
tailptr = &(*tailptr)->m_next;
// add a beam entry: beamx:1234
- *tailptr = auto_alloc(machine(), state_item(REG_BEAMX, "beamx", 4));
+ *tailptr = global_alloc(state_item(REG_BEAMX, "beamx", 4));
tailptr = &(*tailptr)->m_next;
// add a beam entry: beamy:5678
- *tailptr = auto_alloc(machine(), state_item(REG_BEAMY, "beamy", 4));
+ *tailptr = global_alloc(state_item(REG_BEAMY, "beamy", 4));
tailptr = &(*tailptr)->m_next;
// add a beam entry: frame:123456
- *tailptr = auto_alloc(machine(), state_item(REG_FRAME, "frame", 6));
+ *tailptr = global_alloc(state_item(REG_FRAME, "frame", 6));
tailptr = &(*tailptr)->m_next;
// add a flags entry: flags:xxxxxxxx
- *tailptr = auto_alloc(machine(), state_item(STATE_GENFLAGS, "flags", source.m_stateintf->state_string_max_length(STATE_GENFLAGS)));
+ *tailptr = global_alloc(state_item(STATE_GENFLAGS, "flags", source.m_stateintf->state_string_max_length(STATE_GENFLAGS)));
tailptr = &(*tailptr)->m_next;
// add a divider entry
- *tailptr = auto_alloc(machine(), state_item(REG_DIVIDER, "", 0));
+ *tailptr = global_alloc(state_item(REG_DIVIDER, "", 0));
tailptr = &(*tailptr)->m_next;
// add all registers into it
for (const device_state_entry *entry = source.m_stateintf->state_first(); entry != nullptr; entry = entry->next())
if (entry->divider())
{
- *tailptr = auto_alloc(machine(), state_item(REG_DIVIDER, "", 0));
+ *tailptr = global_alloc(state_item(REG_DIVIDER, "", 0));
tailptr = &(*tailptr)->m_next;
}
else if (entry->visible())
{
- *tailptr = auto_alloc(machine(), state_item(entry->index(), entry->symbol(), source.m_stateintf->state_string_max_length(entry->index())));
+ *tailptr = global_alloc(state_item(entry->index(), entry->symbol(), source.m_stateintf->state_string_max_length(entry->index())));
tailptr = &(*tailptr)->m_next;
}
diff --git a/src/emu/emualloc.cpp b/src/emu/emualloc.cpp
index a43faae522c..f424bca39cb 100644
--- a/src/emu/emualloc.cpp
+++ b/src/emu/emualloc.cpp
@@ -38,7 +38,6 @@ UINT64 resource_pool::s_id = 0;
resource_pool::resource_pool(int hash_size)
: m_hash_size(hash_size),
- m_listlock(osd_lock_alloc()),
m_hash(hash_size),
m_ordered_head(nullptr),
m_ordered_tail(nullptr)
@@ -56,8 +55,6 @@ resource_pool::resource_pool(int hash_size)
resource_pool::~resource_pool()
{
clear();
- if (m_listlock != nullptr)
- osd_lock_free(m_listlock);
}
@@ -67,7 +64,7 @@ resource_pool::~resource_pool()
void resource_pool::add(resource_pool_item &item, size_t size, const char *type)
{
- osd_lock_acquire(m_listlock);
+ std::lock_guard<std::mutex> lock(m_listlock);
// insert into hash table
int hashval = reinterpret_cast<FPTR>(item.m_ptr) % m_hash_size;
@@ -107,8 +104,6 @@ void resource_pool::add(resource_pool_item &item, size_t size, const char *type)
item.m_ordered_prev = nullptr;
m_ordered_head = &item;
}
-
- osd_lock_release(m_listlock);
}
@@ -124,7 +119,7 @@ void resource_pool::remove(void *ptr)
return;
// search for the item
- osd_lock_acquire(m_listlock);
+ std::lock_guard<std::mutex> lock(m_listlock);
int hashval = reinterpret_cast<FPTR>(ptr) % m_hash_size;
for (resource_pool_item **scanptr = &m_hash[hashval]; *scanptr != nullptr; scanptr = &(*scanptr)->m_next)
@@ -152,8 +147,6 @@ void resource_pool::remove(void *ptr)
global_free(deleteme);
break;
}
-
- osd_lock_release(m_listlock);
}
@@ -165,7 +158,7 @@ void resource_pool::remove(void *ptr)
resource_pool_item *resource_pool::find(void *ptr)
{
// search for the item
- osd_lock_acquire(m_listlock);
+ std::lock_guard<std::mutex> lock(m_listlock);
int hashval = reinterpret_cast<FPTR>(ptr) % m_hash_size;
resource_pool_item *item;
@@ -173,8 +166,6 @@ resource_pool_item *resource_pool::find(void *ptr)
if (item->m_ptr == ptr)
break;
- osd_lock_release(m_listlock);
-
return item;
}
@@ -190,7 +181,7 @@ bool resource_pool::contains(void *_ptrstart, void *_ptrend)
UINT8 *ptrend = reinterpret_cast<UINT8 *>(_ptrend);
// search for the item
- osd_lock_acquire(m_listlock);
+ std::lock_guard<std::mutex> lock(m_listlock);
resource_pool_item *item = nullptr;
for (item = m_ordered_head; item != nullptr; item = item->m_ordered_next)
@@ -198,13 +189,9 @@ bool resource_pool::contains(void *_ptrstart, void *_ptrend)
UINT8 *objstart = reinterpret_cast<UINT8 *>(item->m_ptr);
UINT8 *objend = objstart + item->m_size;
if (ptrstart >= objstart && ptrend <= objend)
- goto found;
+ return true;
}
-
-found:
- osd_lock_release(m_listlock);
-
- return (item != nullptr);
+ return false;
}
@@ -214,12 +201,8 @@ found:
void resource_pool::clear()
{
- osd_lock_acquire(m_listlock);
-
// important: delete from earliest to latest; this allows objects to clean up after
// themselves if they wish
while (m_ordered_head != nullptr)
remove(m_ordered_head->m_ptr);
-
- osd_lock_release(m_listlock);
}
diff --git a/src/emu/emualloc.h b/src/emu/emualloc.h
index 4571762054f..37b5c63d860 100644
--- a/src/emu/emualloc.h
+++ b/src/emu/emualloc.h
@@ -14,6 +14,7 @@
#define __EMUALLOC_H__
#include <new>
+#include <mutex>
#include "osdcore.h"
#include "coretmpl.h"
@@ -124,7 +125,7 @@ public:
private:
int m_hash_size;
- osd_lock * m_listlock;
+ std::mutex m_listlock;
std::vector<resource_pool_item *> m_hash;
resource_pool_item * m_ordered_head;
resource_pool_item * m_ordered_tail;
diff --git a/src/emu/luaengine.cpp b/src/emu/luaengine.cpp
index f8ec7023bc6..f487c02bed6 100644
--- a/src/emu/luaengine.cpp
+++ b/src/emu/luaengine.cpp
@@ -17,6 +17,7 @@
#include "drivenum.h"
#include "ui/ui.h"
#include "luaengine.h"
+#include <mutex>
//**************************************************************************
// LUA ENGINE
@@ -808,7 +809,7 @@ struct msg {
int done;
} msg;
-osd_lock *lock;
+static std::mutex g_mutex;
void lua_engine::serve_lua()
{
@@ -826,37 +827,39 @@ void lua_engine::serve_lua()
fgets(buff, LUA_MAXINPUT, stdin);
// Create message
- osd_lock_acquire(lock);
- if (msg.ready == 0) {
- msg.text = oldbuff;
- if (oldbuff.length()!=0) msg.text.append("\n");
- msg.text.append(buff);
- msg.ready = 1;
- msg.done = 0;
+ {
+ std::lock_guard<std::mutex> lock(g_mutex);
+ if (msg.ready == 0) {
+ msg.text = oldbuff;
+ if (oldbuff.length() != 0) msg.text.append("\n");
+ msg.text.append(buff);
+ msg.ready = 1;
+ msg.done = 0;
+ }
}
- osd_lock_release(lock);
// Wait for response
int done;
do {
osd_sleep(osd_ticks_per_second() / 1000);
- osd_lock_acquire(lock);
+ std::lock_guard<std::mutex> lock(g_mutex);
done = msg.done;
- osd_lock_release(lock);
} while (done==0);
// Do action on client side
- osd_lock_acquire(lock);
- if (msg.status == -1){
- b = LUA_PROMPT2;
- oldbuff = msg.response;
- }
- else {
- b = LUA_PROMPT;
- oldbuff = "";
+ {
+ osd_sleep(osd_ticks_per_second() / 1000);
+
+ if (msg.status == -1) {
+ b = LUA_PROMPT2;
+ oldbuff = msg.response;
+ }
+ else {
+ b = LUA_PROMPT;
+ oldbuff = "";
+ }
+ msg.done = 0;
}
- msg.done = 0;
- osd_lock_release(lock);
} while (1);
}
@@ -891,7 +894,6 @@ lua_engine::lua_engine()
msg.ready = 0;
msg.status = 0;
msg.done = 0;
- lock = osd_lock_alloc();
}
//-------------------------------------------------
@@ -1046,7 +1048,7 @@ bool lua_engine::frame_hook()
void lua_engine::periodic_check()
{
- osd_lock_acquire(lock);
+ std::lock_guard<std::mutex> lock(g_mutex);
if (msg.ready == 1) {
lua_settop(m_lua_state, 0);
int status = luaL_loadbuffer(m_lua_state, msg.text.c_str(), msg.text.length(), "=stdin");
@@ -1075,7 +1077,6 @@ void lua_engine::periodic_check()
msg.ready = 0;
msg.done = 1;
}
- osd_lock_release(lock);
}
//-------------------------------------------------
diff --git a/src/emu/render.cpp b/src/emu/render.cpp
index 1f8e5d0be1f..e25f62a8e13 100644
--- a/src/emu/render.cpp
+++ b/src/emu/render.cpp
@@ -227,7 +227,6 @@ void render_primitive::reset()
//-------------------------------------------------
render_primitive_list::render_primitive_list()
- : m_lock(osd_lock_alloc())
{
}
@@ -239,7 +238,6 @@ render_primitive_list::render_primitive_list()
render_primitive_list::~render_primitive_list()
{
release_all();
- osd_lock_free(m_lock);
}
@@ -296,10 +294,8 @@ inline render_primitive *render_primitive_list::alloc(render_primitive::primitiv
void render_primitive_list::release_all()
{
// release all the live items while under the lock
- acquire_lock();
m_primitive_allocator.reclaim_all(m_primlist);
m_reference_allocator.reclaim_all(m_reflist);
- release_lock();
}
diff --git a/src/emu/render.h b/src/emu/render.h
index df8896b712b..5be63b085b5 100644
--- a/src/emu/render.h
+++ b/src/emu/render.h
@@ -49,6 +49,7 @@
//#include "osdepend.h"
#include <math.h>
+#include <mutex>
//**************************************************************************
@@ -358,8 +359,8 @@ public:
render_primitive *first() const { return m_primlist.first(); }
// lock management
- void acquire_lock() { osd_lock_acquire(m_lock); }
- void release_lock() { osd_lock_release(m_lock); }
+ void acquire_lock() { m_lock.lock(); }
+ void release_lock() { m_lock.unlock(); }
// reference management
void add_reference(void *refptr);
@@ -388,7 +389,7 @@ private:
fixed_allocator<render_primitive> m_primitive_allocator;// allocator for primitives
fixed_allocator<reference> m_reference_allocator; // allocator for references
- osd_lock * m_lock; // lock to protect list accesses
+ std::mutex m_lock; // lock to protect list accesses
};
diff --git a/src/emu/ui/filemngr.cpp b/src/emu/ui/filemngr.cpp
index d277d0bd847..cccc92888c4 100644
--- a/src/emu/ui/filemngr.cpp
+++ b/src/emu/ui/filemngr.cpp
@@ -195,10 +195,10 @@ void ui_menu_file_manager::force_file_manager(running_machine &machine, render_c
ui_menu::stack_reset(machine);
// add the quit entry followed by the game select entry
- ui_menu *quit = auto_alloc_clear(machine, <ui_menu_quit_game>(machine, container));
+ ui_menu *quit = global_alloc_clear<ui_menu_quit_game>(machine, container);
quit->set_special_main_menu(true);
ui_menu::stack_push(quit);
- ui_menu::stack_push(auto_alloc_clear(machine, <ui_menu_file_manager>(machine, container, warnings)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_file_manager>(machine, container, warnings));
// force the menus on
machine.ui().show_menu();
diff --git a/src/emu/ui/imgcntrl.cpp b/src/emu/ui/imgcntrl.cpp
index 3bb77723726..8f3dbeca75b 100644
--- a/src/emu/ui/imgcntrl.cpp
+++ b/src/emu/ui/imgcntrl.cpp
@@ -190,20 +190,20 @@ void ui_menu_control_device_image::handle()
zippath_closedir(directory);
}
submenu_result = -1;
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_file_selector>(machine(), container, image, current_directory, current_file, true, image->image_interface()!=nullptr, can_create, &submenu_result)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_file_selector>(machine(), container, image, current_directory, current_file, true, image->image_interface()!=nullptr, can_create, &submenu_result));
state = SELECT_FILE;
break;
}
case START_SOFTLIST:
sld = nullptr;
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_software>(machine(), container, image->image_interface(), &sld)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_software>(machine(), container, image->image_interface(), &sld));
state = SELECT_SOFTLIST;
break;
case START_OTHER_PART: {
submenu_result = -1;
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_software_parts>(machine(), container, swi, swp->interface(), &swp, true, &submenu_result)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_software_parts>(machine(), container, swi, swp->interface(), &swp, true, &submenu_result));
state = SELECT_OTHER_PART;
break;
}
@@ -214,7 +214,7 @@ void ui_menu_control_device_image::handle()
break;
}
software_info_name = "";
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_software_list>(machine(), container, sld, image->image_interface(), software_info_name)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_software_list>(machine(), container, sld, image->image_interface(), software_info_name));
state = SELECT_PARTLIST;
break;
@@ -226,7 +226,7 @@ void ui_menu_control_device_image::handle()
{
submenu_result = -1;
swp = nullptr;
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_software_parts>(machine(), container, swi, image->image_interface(), &swp, false, &submenu_result)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_software_parts>(machine(), container, swi, image->image_interface(), &swp, false, &submenu_result));
state = SELECT_ONE_PART;
}
else
@@ -290,7 +290,7 @@ void ui_menu_control_device_image::handle()
break;
case ui_menu_file_selector::R_CREATE:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_file_create>(machine(), container, image, current_directory, current_file, &create_ok)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_file_create>(machine(), container, image, current_directory, current_file, &create_ok));
state = CHECK_CREATE;
break;
@@ -310,7 +310,7 @@ void ui_menu_control_device_image::handle()
test_create(can_create, need_confirm);
if(can_create) {
if(need_confirm) {
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_confirm_save_as>(machine(), container, &create_confirmed)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_confirm_save_as>(machine(), container, &create_confirmed));
state = CREATE_CONFIRM;
} else {
state = DO_CREATE;
diff --git a/src/emu/ui/inputmap.cpp b/src/emu/ui/inputmap.cpp
index 1fc0d046e1f..f3ffe9b0e59 100644
--- a/src/emu/ui/inputmap.cpp
+++ b/src/emu/ui/inputmap.cpp
@@ -73,7 +73,7 @@ void ui_menu_input_groups::handle()
/* process the menu */
const ui_menu_event *menu_event = process(0);
if (menu_event != nullptr && menu_event->iptkey == IPT_UI_SELECT)
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_input_general>(machine(), container, int((long long)(menu_event->itemref)-1))));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_input_general>(machine(), container, int((long long)(menu_event->itemref)-1)));
}
diff --git a/src/emu/ui/mainmenu.cpp b/src/emu/ui/mainmenu.cpp
index 415ad118811..75f16b3d9ba 100644
--- a/src/emu/ui/mainmenu.cpp
+++ b/src/emu/ui/mainmenu.cpp
@@ -152,91 +152,91 @@ void ui_menu_main::handle()
if (menu_event != nullptr && menu_event->iptkey == IPT_UI_SELECT) {
switch((long long)(menu_event->itemref)) {
case INPUT_GROUPS:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_input_groups>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_input_groups>(machine(), container));
break;
case INPUT_SPECIFIC:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_input_specific>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_input_specific>(machine(), container));
break;
case SETTINGS_DIP_SWITCHES:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_settings_dip_switches>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_settings_dip_switches>(machine(), container));
break;
case SETTINGS_DRIVER_CONFIG:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_settings_driver_config>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_settings_driver_config>(machine(), container));
break;
case ANALOG:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_analog>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_analog>(machine(), container));
break;
case BOOKKEEPING:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_bookkeeping>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_bookkeeping>(machine(), container));
break;
case GAME_INFO:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_game_info>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_game_info>(machine(), container));
break;
case IMAGE_MENU_IMAGE_INFO:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_image_info>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_image_info>(machine(), container));
break;
case IMAGE_MENU_FILE_MANAGER:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_file_manager>(machine(), container, nullptr)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_file_manager>(machine(), container, nullptr));
break;
case TAPE_CONTROL:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_tape_control>(machine(), container, nullptr)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_tape_control>(machine(), container, nullptr));
break;
case PTY_INFO:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_pty_info>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_pty_info>(machine(), container));
break;
case SLOT_DEVICES:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_slot_devices>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_slot_devices>(machine(), container));
break;
case NETWORK_DEVICES:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_network_devices>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_network_devices>(machine(), container));
break;
case KEYBOARD_MODE:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_keyboard_mode>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_keyboard_mode>(machine(), container));
break;
case SLIDERS:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_sliders>(machine(), container, false)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_sliders>(machine(), container, false));
break;
case VIDEO_TARGETS:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_video_targets>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_video_targets>(machine(), container));
break;
case VIDEO_OPTIONS:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_video_options>(machine(), container, machine().render().first_target())));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_video_options>(machine(), container, machine().render().first_target()));
break;
case CROSSHAIR:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_crosshair>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_crosshair>(machine(), container));
break;
case CHEAT:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_cheat>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_cheat>(machine(), container));
break;
case SELECT_GAME:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_select_game>(machine(), container, nullptr)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_select_game>(machine(), container, nullptr));
break;
case BIOS_SELECTION:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_bios_selection>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_bios_selection>(machine(), container));
break;
case BARCODE_READ:
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_barcode_reader>(machine(), container, nullptr)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_barcode_reader>(machine(), container, nullptr));
break;
default:
diff --git a/src/emu/ui/menu.cpp b/src/emu/ui/menu.cpp
index 069b05aa913..33604fbbe62 100644
--- a/src/emu/ui/menu.cpp
+++ b/src/emu/ui/menu.cpp
@@ -148,12 +148,12 @@ ui_menu::~ui_menu()
{
ui_menu_pool *ppool = pool;
pool = pool->next;
- auto_free(machine(), ppool);
+ global_free(ppool);
}
// free the item array
if (item)
- auto_free(machine(), item);
+ global_free(item);
}
@@ -247,10 +247,10 @@ void ui_menu::item_append(const char *text, const char *subtext, UINT32 flags, v
{
int olditems = allocitems;
allocitems += UI_MENU_ALLOC_ITEMS;
- ui_menu_item *newitems = auto_alloc_array(machine(), ui_menu_item, allocitems);
+ ui_menu_item *newitems = global_alloc_array(ui_menu_item, allocitems);
for (int itemnum = 0; itemnum < olditems; itemnum++)
newitems[itemnum] = item[itemnum];
- auto_free(machine(), item);
+ global_free(item);
item = newitems;
}
index = numitems++;
@@ -338,7 +338,7 @@ void *ui_menu::m_pool_alloc(size_t size)
}
// allocate a new pool
- ppool = (ui_menu_pool *)auto_alloc_array_clear(machine(), UINT8, sizeof(*ppool) + UI_MENU_POOL_SIZE);
+ ppool = (ui_menu_pool *)global_alloc_array_clear<UINT8>(sizeof(*ppool) + UI_MENU_POOL_SIZE);
// wire it up
ppool->next = pool;
@@ -948,7 +948,7 @@ void ui_menu::clear_free_list(running_machine &machine)
{
ui_menu *menu = menu_free;
menu_free = menu->parent;
- auto_free(machine, menu);
+ global_free(menu);
}
}
@@ -1037,7 +1037,7 @@ UINT32 ui_menu::ui_handler(running_machine &machine, render_container *container
{
// if we have no menus stacked up, start with the main menu
if (menu_stack == nullptr)
- stack_push(auto_alloc_clear(machine, <ui_menu_main>(machine, container)));
+ stack_push(global_alloc_clear<ui_menu_main>(machine, container));
// update the menu state
if (menu_stack != nullptr)
diff --git a/src/emu/ui/selgame.cpp b/src/emu/ui/selgame.cpp
index 9a080df6655..19af6e607d8 100644
--- a/src/emu/ui/selgame.cpp
+++ b/src/emu/ui/selgame.cpp
@@ -141,7 +141,7 @@ void ui_menu_select_game::inkey_select(const ui_menu_event *menu_event)
// special case for configure inputs
if ((FPTR)driver == 1)
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_input_groups>(machine(), container)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_input_groups>(machine(), container));
// anything else is a driver
else
@@ -180,7 +180,7 @@ void ui_menu_select_game::inkey_cancel(const ui_menu_event *menu_event)
if (m_search[0] != 0)
{
// since we have already been popped, we must recreate ourself from scratch
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_select_game>(machine(), container, nullptr)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_select_game>(machine(), container, nullptr));
}
}
@@ -429,10 +429,10 @@ void ui_menu_select_game::force_game_select(running_machine &machine, render_con
ui_menu::stack_reset(machine);
// add the quit entry followed by the game select entry
- ui_menu *quit = auto_alloc_clear(machine, <ui_menu_quit_game>(machine, container));
+ ui_menu *quit = global_alloc_clear<ui_menu_quit_game>(machine, container);
quit->set_special_main_menu(true);
ui_menu::stack_push(quit);
- ui_menu::stack_push(auto_alloc_clear(machine, <ui_menu_select_game>(machine, container, gamename)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_select_game>(machine, container, gamename));
// force the menus on
machine.ui().show_menu();
diff --git a/src/emu/ui/sliders.cpp b/src/emu/ui/sliders.cpp
index 26da6327202..23bd9013dba 100644
--- a/src/emu/ui/sliders.cpp
+++ b/src/emu/ui/sliders.cpp
@@ -242,7 +242,7 @@ UINT32 ui_menu_sliders::ui_handler(running_machine &machine, render_container *c
/* if this is the first call, push the sliders menu */
if (state)
- ui_menu::stack_push(auto_alloc_clear(machine, <ui_menu_sliders>(machine, container, true)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_sliders>(machine, container, true));
/* handle standard menus */
result = ui_menu::ui_handler(machine, container, state);
diff --git a/src/emu/ui/slotopt.cpp b/src/emu/ui/slotopt.cpp
index cce17353532..a3b6352ac2b 100644
--- a/src/emu/ui/slotopt.cpp
+++ b/src/emu/ui/slotopt.cpp
@@ -204,7 +204,7 @@ void ui_menu_slot_devices::handle()
device_slot_interface *slot = (device_slot_interface *)menu_event->itemref;
device_slot_option *option = slot_get_current_option(slot);
if (option)
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_device_config>(machine(), container, slot, option)));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_device_config>(machine(), container, slot, option));
}
}
}
diff --git a/src/emu/ui/swlist.cpp b/src/emu/ui/swlist.cpp
index 64eb5109fae..d57c91fae40 100644
--- a/src/emu/ui/swlist.cpp
+++ b/src/emu/ui/swlist.cpp
@@ -448,7 +448,7 @@ void ui_menu_software::handle()
const ui_menu_event *event = process(0);
if (event != nullptr && event->iptkey == IPT_UI_SELECT) {
- // ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_software_list>(machine(), container, (software_list_config *)event->itemref, image)));
+ // ui_menu::stack_push(global_alloc_clear<ui_menu_software_list>(machine(), container, (software_list_config *)event->itemref, image));
*m_result = (software_list_device *)event->itemref;
ui_menu::stack_pop(machine());
}
diff --git a/src/emu/ui/videoopt.cpp b/src/emu/ui/videoopt.cpp
index e76c27305c8..aa3bc21dd5f 100644
--- a/src/emu/ui/videoopt.cpp
+++ b/src/emu/ui/videoopt.cpp
@@ -24,7 +24,7 @@ void ui_menu_video_targets::handle()
/* process the menu */
const ui_menu_event *menu_event = process(0);
if (menu_event != nullptr && menu_event->iptkey == IPT_UI_SELECT)
- ui_menu::stack_push(auto_alloc_clear(machine(), <ui_menu_video_options>(machine(), container, static_cast<render_target *>(menu_event->itemref))));
+ ui_menu::stack_push(global_alloc_clear<ui_menu_video_options>(machine(), container, static_cast<render_target *>(menu_event->itemref)));
}
diff --git a/src/mame/includes/chihiro.h b/src/mame/includes/chihiro.h
index a9efcc711e3..0f68747059a 100644
--- a/src/mame/includes/chihiro.h
+++ b/src/mame/includes/chihiro.h
@@ -3,6 +3,8 @@
/*
* geforce 3d (NV2A) vertex program disassembler
*/
+#include <mutex>
+
class vertex_program_disassembler {
static const char *srctypes[];
static const char *scaops[];
@@ -357,7 +359,6 @@ public:
objectdata = &(object_data_alloc());
objectdata->data = this;
combiner.used = 0;
- combiner.lock = osd_lock_alloc();
enabled_vertex_attributes = 0;
indexesleft_count = 0;
vertex_pipeline = 4;
@@ -626,7 +627,7 @@ public:
} final;
int stages;
int used;
- osd_lock *lock;
+ std::mutex lock;
} combiner;
UINT32 color_mask;
bool alpha_test_enabled;
diff --git a/src/mame/video/chihiro.cpp b/src/mame/video/chihiro.cpp
index 9f803c45651..e6c8e578bb6 100644
--- a/src/mame/video/chihiro.cpp
+++ b/src/mame/video/chihiro.cpp
@@ -1953,7 +1953,7 @@ void nv2a_renderer::render_register_combiners(INT32 scanline, const extent_t &ex
if ((extent.startx < 0) || (extent.stopx > 640))
return;
- osd_lock_acquire(combiner.lock); // needed since multithreading is not supported yet
+ std::lock_guard<std::mutex> lock(combiner.lock); // needed since multithreading is not supported yet
x = extent.stopx - extent.startx - 1; // number of pixels to draw
while (x >= 0) {
xp = extent.startx + x;
@@ -1998,7 +1998,6 @@ void nv2a_renderer::render_register_combiners(INT32 scanline, const extent_t &ex
write_pixel(xp, scanline, a8r8g8b8, z);
x--;
}
- osd_lock_release(combiner.lock);
}
#if 0
diff --git a/src/osd/modules/sound/xaudio2_sound.cpp b/src/osd/modules/sound/xaudio2_sound.cpp
index 7df854c0364..9dc3d0461be 100644
--- a/src/osd/modules/sound/xaudio2_sound.cpp
+++ b/src/osd/modules/sound/xaudio2_sound.cpp
@@ -14,6 +14,7 @@
// standard windows headers
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
+#include <mutex>
#pragma warning( push )
#pragma warning( disable: 4068 )
@@ -124,21 +125,12 @@ public:
obj->DestroyVoice();
}
}
-
- void operator()(osd_lock* obj) const
- {
- if (obj != nullptr)
- {
- osd_lock_free(obj);
- }
- }
};
// Typedefs for smart pointers used with customer deleters
typedef std::unique_ptr<IXAudio2, xaudio2_custom_deleter> xaudio2_ptr;
typedef std::unique_ptr<IXAudio2MasteringVoice, xaudio2_custom_deleter> mastering_voice_ptr;
typedef std::unique_ptr<IXAudio2SourceVoice, xaudio2_custom_deleter> src_voice_ptr;
-typedef std::unique_ptr<osd_lock, xaudio2_custom_deleter> osd_lock_ptr;
// Typedef for pointer to XAudio2Create
typedef HRESULT(__stdcall* PFN_XAUDIO2CREATE)(IXAudio2**, UINT32, XAUDIO2_PROCESSOR);
@@ -147,27 +139,6 @@ typedef HRESULT(__stdcall* PFN_XAUDIO2CREATE)(IXAudio2**, UINT32, XAUDIO2_PROCES
// Helper classes
//============================================================
-// Helper for locking within a particular scope without having to manually release
-class osd_scoped_lock
-{
-private:
- osd_lock * m_lock;
-public:
- osd_scoped_lock(osd_lock* lock)
- {
- m_lock = lock;
- osd_lock_acquire(m_lock);
- }
-
- ~osd_scoped_lock()
- {
- if (m_lock != nullptr)
- {
- osd_lock_release(m_lock);
- }
- }
-};
-
// Provides a pool of buffers
class bufferpool
{
@@ -233,7 +204,7 @@ private:
DWORD m_buffer_size;
DWORD m_buffer_count;
DWORD m_writepos;
- osd_lock_ptr m_buffer_lock;
+ std::mutex m_buffer_lock;
HANDLE m_hEventBufferCompleted;
HANDLE m_hEventDataAvailable;
HANDLE m_hEventExiting;
@@ -258,7 +229,6 @@ public:
m_buffer_size(0),
m_buffer_count(0),
m_writepos(0),
- m_buffer_lock(osd_lock_alloc()),
m_hEventBufferCompleted(NULL),
m_hEventDataAvailable(NULL),
m_hEventExiting(NULL),
@@ -389,7 +359,7 @@ void sound_xaudio2::update_audio_stream(
UINT32 const bytes_this_frame = samples_this_frame * m_sample_bytes;
- osd_scoped_lock scope_lock(m_buffer_lock.get());
+ std::lock_guard<std::mutex> lock(m_buffer_lock);
UINT32 bytes_left = bytes_this_frame;
@@ -446,7 +416,7 @@ void sound_xaudio2::OnBufferEnd(void *pBufferContext)
BYTE* completed_buffer = (BYTE*)pBufferContext;
if (completed_buffer != nullptr)
{
- auto scoped_lock = osd_scoped_lock(m_buffer_lock.get());
+ std::lock_guard<std::mutex> lock(m_buffer_lock);
m_buffer_pool->return_to_pool(completed_buffer);
}
@@ -625,7 +595,7 @@ void sound_xaudio2::submit_needed()
if (state.BuffersQueued >= 1)
return;
- osd_scoped_lock lock_scope(m_buffer_lock.get());
+ std::lock_guard<std::mutex> lock(m_buffer_lock);
// Roll the buffer
roll_buffer();
diff --git a/src/osd/modules/sync/osdsync.h b/src/osd/modules/sync/osdsync.h
index 46d32b09135..e6e5e2f99c9 100644
--- a/src/osd/modules/sync/osdsync.h
+++ b/src/osd/modules/sync/osdsync.h
@@ -24,7 +24,7 @@ struct osd_event;
/*-----------------------------------------------------------------------------
- osd_lock_event_alloc: allocate a new event
+ osd_event_alloc: allocate a new event
Parameters:
@@ -174,18 +174,4 @@ int osd_thread_cpu_affinity(osd_thread *thread, UINT32 mask);
-----------------------------------------------------------------------------*/
void osd_thread_wait_free(osd_thread *thread);
-//============================================================
-// Scalable Locks
-//============================================================
-
-struct osd_scalable_lock;
-
-osd_scalable_lock *osd_scalable_lock_alloc(void);
-
-INT32 osd_scalable_lock_acquire(osd_scalable_lock *lock);
-
-void osd_scalable_lock_release(osd_scalable_lock *lock, INT32 myslot);
-
-void osd_scalable_lock_free(osd_scalable_lock *lock);
-
#endif /* __OSDSYNC__ */
diff --git a/src/osd/modules/sync/sync_mini.cpp b/src/osd/modules/sync/sync_mini.cpp
index f5e6accb0c7..5829eb6d63c 100644
--- a/src/osd/modules/sync/sync_mini.cpp
+++ b/src/osd/modules/sync/sync_mini.cpp
@@ -20,63 +20,6 @@ struct _osd_thread {
//============================================================
-// osd_lock_alloc
-//============================================================
-
-osd_lock *osd_lock_alloc(void)
-{
- // the minimal implementation does not support threading
- // just return a dummy value here
- return (osd_lock *)1;
-}
-
-
-//============================================================
-// osd_lock_acquire
-//============================================================
-
-void osd_lock_acquire(osd_lock *lock)
-{
- // the minimal implementation does not support threading
- // the acquire always "succeeds"
-}
-
-
-//============================================================
-// osd_lock_try
-//============================================================
-
-int osd_lock_try(osd_lock *lock)
-{
- // the minimal implementation does not support threading
- // the acquire always "succeeds"
- return TRUE;
-}
-
-
-//============================================================
-// osd_lock_release
-//============================================================
-
-void osd_lock_release(osd_lock *lock)
-{
- // the minimal implementation does not support threading
- // do nothing here
-}
-
-
-//============================================================
-// osd_lock_free
-//============================================================
-
-void osd_lock_free(osd_lock *lock)
-{
- // the minimal implementation does not support threading
- // do nothing here
-}
-
-
-//============================================================
// osd_event_alloc
//============================================================
diff --git a/src/osd/modules/sync/sync_ntc.cpp b/src/osd/modules/sync/sync_ntc.cpp
index 462c56ee434..c78f67ce64a 100644
--- a/src/osd/modules/sync/sync_ntc.cpp
+++ b/src/osd/modules/sync/sync_ntc.cpp
@@ -38,16 +38,6 @@
#include <errno.h>
#include <sys/time.h>
-struct osd_lock {
- volatile pthread_t holder;
- INT32 count;
-#ifdef PTR64
- INT8 padding[52]; // Fill a 64-byte cache line
-#else
- INT8 padding[56]; // A bit more padding
-#endif
-};
-
struct osd_event {
pthread_mutex_t mutex;
pthread_cond_t cond;
@@ -69,275 +59,6 @@ struct osd_thread {
pthread_t thread;
};
-struct osd_scalable_lock
-{
- struct
- {
- volatile INT32 haslock; // do we have the lock?
- INT32 filler[64/4-1]; // assumes a 64-byte cache line
- } slot[WORK_MAX_THREADS]; // one slot per thread
- volatile INT32 nextindex; // index of next slot to use
-};
-
-
-//============================================================
-// Scalable Locks
-//============================================================
-
-osd_scalable_lock *osd_scalable_lock_alloc(void)
-{
- osd_scalable_lock *lock;
-
- lock = (osd_scalable_lock *)calloc(1, sizeof(*lock));
- if (lock == NULL)
- return NULL;
-
- memset(lock, 0, sizeof(*lock));
- lock->slot[0].haslock = TRUE;
- return lock;
-}
-
-
-INT32 osd_scalable_lock_acquire(osd_scalable_lock *lock)
-{
- INT32 myslot = (atomic_increment32(&lock->nextindex) - 1) & (WORK_MAX_THREADS - 1);
-
-#if defined(__i386__) || defined(__x86_64__)
- register INT32 tmp;
- __asm__ __volatile__ (
- "1: clr %[tmp] ;"
- " xchg %[haslock], %[tmp] ;"
- " test %[tmp], %[tmp] ;"
- " jne 3f ;"
- "2: mov %[haslock], %[tmp] ;"
- " test %[tmp], %[tmp] ;"
- " jne 1b ;"
- " pause ;"
- " jmp 2b ;"
- "3: "
- : [haslock] "+m" (lock->slot[myslot].haslock)
- , [tmp] "=&r" (tmp)
- :
- : "cc"
- );
-#elif defined(__ppc__) || defined (__PPC__) || defined(__ppc64__) || defined(__PPC64__)
- register INT32 tmp;
- __asm__ __volatile__ (
- "1: lwarx %[tmp], 0, %[haslock] \n"
- " cmpwi %[tmp], 0 \n"
- " bne 3f \n"
- "2: lwzx %[tmp], 0, %[haslock] \n"
- " cmpwi %[tmp], 0 \n"
- " bne 1b \n"
- " nop \n"
- " nop \n"
- " b 2b \n"
- "3: li %[tmp], 0 \n"
- " stwcx. %[tmp], 0, %[haslock] \n"
- " bne- 1b \n"
- " lwsync \n"
- : [tmp] "=&r" (tmp)
- : [haslock] "r" (&lock->slot[myslot].haslock)
- : "cr0"
- );
-#else
- INT32 backoff = 1;
- while (!osd_compare_exchange32(&lock->slot[myslot].haslock, TRUE, FALSE))
- {
- INT32 backcount;
- for (backcount = 0; backcount < backoff; backcount++)
- osd_yield_processor();
- backoff <<= 1;
- }
-#endif
- return myslot;
-}
-
-
-void osd_scalable_lock_release(osd_scalable_lock *lock, INT32 myslot)
-{
-#if defined(__i386__) || defined(__x86_64__)
- register INT32 tmp = TRUE;
- __asm__ __volatile__ (
- " xchg %[haslock], %[tmp] ;"
- : [haslock] "+m" (lock->slot[(myslot + 1) & (WORK_MAX_THREADS - 1)].haslock)
- , [tmp] "+r" (tmp)
- :
- );
-#elif defined(__ppc__) || defined (__PPC__) || defined(__ppc64__) || defined(__PPC64__)
- lock->slot[(myslot + 1) & (WORK_MAX_THREADS - 1)].haslock = TRUE;
- __asm__ __volatile__ ( " lwsync " : : );
-#else
- osd_exchange32(&lock->slot[(myslot + 1) & (WORK_MAX_THREADS - 1)].haslock, TRUE);
-#endif
-}
-
-void osd_scalable_lock_free(osd_scalable_lock *lock)
-{
- free(lock);
-}
-
-static inline pthread_t osd_compare_exchange_pthread_t(pthread_t volatile *ptr, pthread_t compare, pthread_t exchange)
-{
-#ifdef PTR64
- INT64 result = compare_exchange64((INT64 volatile *)ptr, (INT64)compare, (INT64)exchange);
-#else
- INT32 result = compare_exchange32((INT32 volatile *)ptr, (INT32)compare, (INT32)exchange);
-#endif
- return (pthread_t)result;
-}
-
-static inline pthread_t osd_exchange_pthread_t(pthread_t volatile *ptr, pthread_t exchange)
-{
-#ifdef PTR64
- INT64 result = osd_exchange64((INT64 volatile *)ptr, (INT64)exchange);
-#else
- INT32 result = atomic_exchange32((INT32 volatile *)ptr, (INT32)exchange);
-#endif
- return (pthread_t)result;
-}
-
-
-//============================================================
-// osd_lock_alloc
-//============================================================
-
-osd_lock *osd_lock_alloc(void)
-{
- osd_lock *lock;
-
- lock = (osd_lock *)calloc(1, sizeof(osd_lock));
- if (lock == NULL)
- return NULL;
-
- lock->holder = 0;
- lock->count = 0;
-
- return lock;
-}
-
-//============================================================
-// osd_lock_acquire
-//============================================================
-
-void osd_lock_acquire(osd_lock *lock)
-{
- pthread_t current, prev;
-
- current = pthread_self();
- prev = osd_compare_exchange_pthread_t(&lock->holder, 0, current);
- if (prev != nullptr && prev != current)
- {
- do {
- register INT32 spin = 10000; // Convenient spin count
- register pthread_t tmp;
-#if defined(__i386__) || defined(__x86_64__)
- __asm__ __volatile__ (
- "1: pause ;"
- " mov %[holder], %[tmp] ;"
- " test %[tmp], %[tmp] ;"
- " loopne 1b ;"
- : [spin] "+c" (spin)
- , [tmp] "=&r" (tmp)
- : [holder] "m" (lock->holder)
- : "cc"
- );
-#elif defined(__ppc__) || defined(__PPC__)
- __asm__ __volatile__ (
- "1: nop \n"
- " nop \n"
- " lwzx %[tmp], 0, %[holder] \n"
- " cmpwi %[tmp], 0 \n"
- " bdnzt eq, 1b \n"
- : [spin] "+c" (spin)
- , [tmp] "=&r" (tmp)
- : [holder] "r" (&lock->holder)
- : "cr0"
- );
-#elif defined(__ppc64__) || defined(__PPC64__)
- __asm__ __volatile__ (
- "1: nop \n"
- " nop \n"
- " ldx %[tmp], 0, %[holder] \n"
- " cmpdi %[tmp], 0 \n"
- " bdnzt eq, 1b \n"
- : [spin] "+c" (spin)
- , [tmp] "=&r" (tmp)
- : [holder] "r" (&lock->holder)
- : "cr0"
- );
-#else
- while (--spin > 0 && lock->holder != NULL)
- osd_yield_processor();
-#endif
-#if 0
- /* If you mean to use locks as a blocking mechanism for extended
- * periods of time, you should do something like this. However,
- * it kills the performance of gaelco3d.
- */
- if (spin == 0)
- {
- struct timespec sleep = { 0, 100000 }, remaining;
- nanosleep(&sleep, &remaining); // sleep for 100us
- }
-#endif
- } while (osd_compare_exchange_pthread_t(&lock->holder, 0, current) != nullptr);
- }
- lock->count++;
-}
-
-//============================================================
-// osd_lock_try
-//============================================================
-
-int osd_lock_try(osd_lock *lock)
-{
- pthread_t current, prev;
-
- current = pthread_self();
- prev = osd_compare_exchange_pthread_t(&lock->holder, 0, current);
- if (prev == nullptr || prev == current)
- {
- lock->count++;
- return 1;
- }
- return 0;
-}
-
-//============================================================
-// osd_lock_release
-//============================================================
-
-void osd_lock_release(osd_lock *lock)
-{
- pthread_t current;
-
- current = pthread_self();
- if (lock->holder == current)
- {
- if (--lock->count == 0)
-#if defined(__ppc__) || defined(__PPC__) || defined(__ppc64__) || defined(__PPC64__)
- lock->holder = 0;
- __asm__ __volatile__( " lwsync " : : );
-#else
- osd_exchange_pthread_t(&lock->holder, 0);
-#endif
- return;
- }
-
- // trying to release a lock you don't hold is bad!
-// assert(lock->holder == pthread_self());
-}
-
-//============================================================
-// osd_lock_free
-//============================================================
-
-void osd_lock_free(osd_lock *lock)
-{
- free(lock);
-}
-
//============================================================
// osd_event_alloc
//============================================================
diff --git a/src/osd/modules/sync/sync_os2.cpp b/src/osd/modules/sync/sync_os2.cpp
index dba34065610..6e3265bb198 100644
--- a/src/osd/modules/sync/sync_os2.cpp
+++ b/src/osd/modules/sync/sync_os2.cpp
@@ -31,16 +31,6 @@
#define pthread_t int
#define pthread_self _gettid
-struct osd_lock {
- volatile pthread_t holder;
- INT32 count;
-#ifdef PTR64
- INT8 padding[52]; // Fill a 64-byte cache line
-#else
- INT8 padding[56]; // A bit more padding
-#endif
-};
-
struct osd_event {
HMTX hmtx;
HEV hev;
@@ -58,276 +48,6 @@ struct osd_thread {
void *param;
};
-struct osd_scalable_lock
-{
- struct
- {
- volatile INT32 haslock; // do we have the lock?
- INT32 filler[64/4-1]; // assumes a 64-byte cache line
- } slot[WORK_MAX_THREADS]; // one slot per thread
- volatile INT32 nextindex; // index of next slot to use
-};
-
-
-//============================================================
-// Scalable Locks
-//============================================================
-
-osd_scalable_lock *osd_scalable_lock_alloc(void)
-{
- osd_scalable_lock *lock;
-
- lock = (osd_scalable_lock *)calloc(1, sizeof(*lock));
- if (lock == NULL)
- return NULL;
-
- memset(lock, 0, sizeof(*lock));
- lock->slot[0].haslock = TRUE;
- return lock;
-}
-
-
-INT32 osd_scalable_lock_acquire(osd_scalable_lock *lock)
-{
- INT32 myslot = (atomic_increment32(&lock->nextindex) - 1) & (WORK_MAX_THREADS - 1);
-
-#if defined(__i386__) || defined(__x86_64__)
- register INT32 tmp;
- __asm__ __volatile__ (
- "1: clr %[tmp] ;"
- " xchg %[haslock], %[tmp] ;"
- " test %[tmp], %[tmp] ;"
- " jne 3f ;"
- "2: mov %[haslock], %[tmp] ;"
- " test %[tmp], %[tmp] ;"
- " jne 1b ;"
- " pause ;"
- " jmp 2b ;"
- "3: "
- : [haslock] "+m" (lock->slot[myslot].haslock)
- , [tmp] "=&r" (tmp)
- :
- : "%cc"
- );
-#elif defined(__ppc__) || defined (__PPC__) || defined(__ppc64__) || defined(__PPC64__)
- register INT32 tmp;
- __asm__ __volatile__ (
- "1: lwarx %[tmp], 0, %[haslock] \n"
- " cmpwi %[tmp], 0 \n"
- " bne 3f \n"
- "2: lwzx %[tmp], 0, %[haslock] \n"
- " cmpwi %[tmp], 0 \n"
- " bne 1b \n"
- " nop \n"
- " nop \n"
- " b 2b \n"
- "3: li %[tmp], 0 \n"
- " sync \n"
- " stwcx. %[tmp], 0, %[haslock] \n"
- " bne- 1b \n"
- " eieio \n"
- : [tmp] "=&r" (tmp)
- : [haslock] "r" (&lock->slot[myslot].haslock)
- : "cr0"
- );
-#else
- INT32 backoff = 1;
- while (!osd_compare_exchange32(&lock->slot[myslot].haslock, TRUE, FALSE))
- {
- INT32 backcount;
- for (backcount = 0; backcount < backoff; backcount++)
- osd_yield_processor();
- backoff <<= 1;
- }
-#endif
- return myslot;
-}
-
-
-void osd_scalable_lock_release(osd_scalable_lock *lock, INT32 myslot)
-{
-#if defined(__i386__) || defined(__x86_64__)
- register INT32 tmp = TRUE;
- __asm__ __volatile__ (
- " xchg %[haslock], %[tmp] ;"
- : [haslock] "+m" (lock->slot[(myslot + 1) & (WORK_MAX_THREADS - 1)].haslock)
- , [tmp] "+r" (tmp)
- :
- );
-#elif defined(__ppc__) || defined (__PPC__) || defined(__ppc64__) || defined(__PPC64__)
- lock->slot[(myslot + 1) & (WORK_MAX_THREADS - 1)].haslock = TRUE;
- __asm__ __volatile__ ( " eieio " : : );
-#else
- osd_exchange32(&lock->slot[(myslot + 1) & (WORK_MAX_THREADS - 1)].haslock, TRUE);
-#endif
-}
-
-void osd_scalable_lock_free(osd_scalable_lock *lock)
-{
- free(lock);
-}
-
-static inline pthread_t osd_compare_exchange_pthread_t(pthread_t volatile *ptr, pthread_t compare, pthread_t exchange)
-{
-#ifdef PTR64
- INT64 result = compare_exchange64((INT64 volatile *)ptr, (INT64)compare, (INT64)exchange);
-#else
- INT32 result = compare_exchange32((INT32 volatile *)ptr, (INT32)compare, (INT32)exchange);
-#endif
- return (pthread_t)result;
-}
-
-static inline pthread_t osd_exchange_pthread_t(pthread_t volatile *ptr, pthread_t exchange)
-{
-#ifdef PTR64
- INT64 result = osd_exchange64((INT64 volatile *)ptr, (INT64)exchange);
-#else
- INT32 result = atomic_exchange32((INT32 volatile *)ptr, (INT32)exchange);
-#endif
- return (pthread_t)result;
-}
-
-
-//============================================================
-// osd_lock_alloc
-//============================================================
-
-osd_lock *osd_lock_alloc(void)
-{
- osd_lock *lock;
-
- lock = (osd_lock *)calloc(1, sizeof(osd_lock));
- if (lock == NULL)
- return NULL;
-
- lock->holder = 0;
- lock->count = 0;
-
- return lock;
-}
-
-//============================================================
-// osd_lock_acquire
-//============================================================
-
-void osd_lock_acquire(osd_lock *lock)
-{
- pthread_t current, prev;
-
- current = pthread_self();
- prev = osd_compare_exchange_pthread_t(&lock->holder, 0, current);
- if (prev != (size_t)NULL && prev != current)
- {
- do {
- register INT32 spin = 10000; // Convenient spin count
- register pthread_t tmp;
-#if defined(__i386__) || defined(__x86_64__)
- __asm__ __volatile__ (
- "1: pause ;"
- " mov %[holder], %[tmp] ;"
- " test %[tmp], %[tmp] ;"
- " loopne 1b ;"
- : [spin] "+c" (spin)
- , [tmp] "=&r" (tmp)
- : [holder] "m" (lock->holder)
- : "%cc"
- );
-#elif defined(__ppc__) || defined(__PPC__)
- __asm__ __volatile__ (
- "1: nop \n"
- " nop \n"
- " lwzx %[tmp], 0, %[holder] \n"
- " cmpwi %[tmp], 0 \n"
- " bdnzt eq, 1b \n"
- : [spin] "+c" (spin)
- , [tmp] "=&r" (tmp)
- : [holder] "r" (&lock->holder)
- : "cr0"
- );
-#elif defined(__ppc64__) || defined(__PPC64__)
- __asm__ __volatile__ (
- "1: nop \n"
- " nop \n"
- " ldx %[tmp], 0, %[holder] \n"
- " cmpdi %[tmp], 0 \n"
- " bdnzt eq, 1b \n"
- : [spin] "+c" (spin)
- , [tmp] "=&r" (tmp)
- : [holder] "r" (&lock->holder)
- : "cr0"
- );
-#else
- while (--spin > 0 && lock->holder != NULL)
- osd_yield_processor();
-#endif
-#if 0
- /* If you mean to use locks as a blocking mechanism for extended
- * periods of time, you should do something like this. However,
- * it kills the performance of gaelco3d.
- */
- if (spin == 0)
- {
- struct timespec sleep = { 0, 100000 }, remaining;
- nanosleep(&sleep, &remaining); // sleep for 100us
- }
-#endif
- } while (osd_compare_exchange_pthread_t(&lock->holder, 0, current) != (size_t)NULL);
- }
- lock->count++;
-}
-
-//============================================================
-// osd_lock_try
-//============================================================
-
-int osd_lock_try(osd_lock *lock)
-{
- pthread_t current, prev;
-
- current = pthread_self();
- prev = osd_compare_exchange_pthread_t(&lock->holder, 0, current);
- if (prev == (size_t)NULL || prev == current)
- {
- lock->count++;
- return 1;
- }
- return 0;
-}
-
-//============================================================
-// osd_lock_release
-//============================================================
-
-void osd_lock_release(osd_lock *lock)
-{
- pthread_t current;
-
- current = pthread_self();
- if (lock->holder == current)
- {
- if (--lock->count == 0)
-#if defined(__ppc__) || defined(__PPC__) || defined(__ppc64__) || defined(__PPC64__)
- lock->holder = 0;
- __asm__ __volatile__( " eieio " : : );
-#else
- osd_exchange_pthread_t(&lock->holder, 0);
-#endif
- return;
- }
-
- // trying to release a lock you don't hold is bad!
-// assert(lock->holder == pthread_self());
-}
-
-//============================================================
-// osd_lock_free
-//============================================================
-
-void osd_lock_free(osd_lock *lock)
-{
- free(lock);
-}
-
//============================================================
// osd_event_alloc
//============================================================
diff --git a/src/osd/modules/sync/sync_sdl.cpp b/src/osd/modules/sync/sync_sdl.cpp
index 90969b2a068..8a525723a45 100644
--- a/src/osd/modules/sync/sync_sdl.cpp
+++ b/src/osd/modules/sync/sync_sdl.cpp
@@ -51,138 +51,6 @@ struct osd_thread {
void *param;
};
-struct osd_scalable_lock
-{
- SDL_mutex * mutex;
-};
-
-//============================================================
-// Scalable Locks
-//============================================================
-
-osd_scalable_lock *osd_scalable_lock_alloc(void)
-{
- osd_scalable_lock *lock;
-
- lock = (osd_scalable_lock *)calloc(1, sizeof(*lock));
- if (lock == NULL)
- return NULL;
-
- lock->mutex = SDL_CreateMutex();
- return lock;
-}
-
-
-INT32 osd_scalable_lock_acquire(osd_scalable_lock *lock)
-{
- SDL_mutexP(lock->mutex);
- return 0;
-}
-
-
-void osd_scalable_lock_release(osd_scalable_lock *lock, INT32 myslot)
-{
- SDL_mutexV(lock->mutex);
-}
-
-void osd_scalable_lock_free(osd_scalable_lock *lock)
-{
- SDL_DestroyMutex(lock->mutex);
- free(lock);
-}
-
-//============================================================
-// osd_lock_alloc
-//============================================================
-
-osd_lock *osd_lock_alloc(void)
-{
- hidden_mutex_t *mutex;
-
- mutex = (hidden_mutex_t *)calloc(1, sizeof(hidden_mutex_t));
- if (mutex == NULL)
- return NULL;
-
- mutex->id = SDL_CreateMutex();
-
- return (osd_lock *)mutex;
-}
-
-//============================================================
-// osd_lock_acquire
-//============================================================
-
-void osd_lock_acquire(osd_lock *lock)
-{
- hidden_mutex_t *mutex = (hidden_mutex_t *) lock;
-
- LOG(("osd_lock_acquire"));
- /* get the lock */
- mutex->locked++; /* signal that we are *about* to lock - prevent osd_lock_try */
- SDL_mutexP(mutex->id);
- mutex->threadid = SDL_ThreadID();
-}
-
-//============================================================
-// osd_lock_try
-//============================================================
-
-int osd_lock_try(osd_lock *lock)
-{
- hidden_mutex_t *mutex = (hidden_mutex_t *) lock;
-
- LOG(("osd_lock_try"));
- if (mutex->locked && mutex->threadid == SDL_ThreadID())
- {
- /* get the lock */
- SDL_mutexP(mutex->id);
- mutex->locked++;
- mutex->threadid = SDL_ThreadID();
- return 1;
- }
- else if ((mutex->locked == 0))
- {
- /* get the lock */
- mutex->locked++;
- SDL_mutexP(mutex->id);
- mutex->threadid = SDL_ThreadID();
- return 1;
- }
- else
- {
- /* fail */
- return 0;
- }
-}
-
-//============================================================
-// osd_lock_release
-//============================================================
-
-void osd_lock_release(osd_lock *lock)
-{
- hidden_mutex_t *mutex = (hidden_mutex_t *) lock;
-
- LOG(("osd_lock_release"));
- mutex->locked--;
- if (mutex->locked == 0)
- mutex->threadid = -1;
- SDL_mutexV(mutex->id);
-}
-
-//============================================================
-// osd_lock_free
-//============================================================
-
-void osd_lock_free(osd_lock *lock)
-{
- hidden_mutex_t *mutex = (hidden_mutex_t *) lock;
-
- LOG(("osd_lock_free"));
- //osd_lock_release(lock);
- SDL_DestroyMutex(mutex->id);
- free(mutex);
-}
//============================================================
// osd_event_alloc
diff --git a/src/osd/modules/sync/sync_tc.cpp b/src/osd/modules/sync/sync_tc.cpp
index 06dc699edce..64a6a760e96 100644
--- a/src/osd/modules/sync/sync_tc.cpp
+++ b/src/osd/modules/sync/sync_tc.cpp
@@ -58,123 +58,6 @@ struct osd_thread {
pthread_t thread;
};
-struct osd_scalable_lock
-{
- osd_lock *lock;
-};
-
-//============================================================
-// Scalable Locks
-//============================================================
-
-osd_scalable_lock *osd_scalable_lock_alloc(void)
-{
- osd_scalable_lock *lock;
-
- lock = (osd_scalable_lock *)calloc(1, sizeof(*lock));
- if (lock == NULL)
- return NULL;
-
- lock->lock = osd_lock_alloc();
- return lock;
-}
-
-
-INT32 osd_scalable_lock_acquire(osd_scalable_lock *lock)
-{
- osd_lock_acquire(lock->lock);
- return 0;
-}
-
-
-void osd_scalable_lock_release(osd_scalable_lock *lock, INT32 myslot)
-{
- osd_lock_release(lock->lock);
-}
-
-void osd_scalable_lock_free(osd_scalable_lock *lock)
-{
- osd_lock_free(lock->lock);
- free(lock);
-}
-
-
-//============================================================
-// osd_lock_alloc
-//============================================================
-
-osd_lock *osd_lock_alloc(void)
-{
- hidden_mutex_t *mutex;
- pthread_mutexattr_t mtxattr;
-
- mutex = (hidden_mutex_t *)calloc(1, sizeof(hidden_mutex_t));
- if (mutex == NULL)
- return NULL;
-
- pthread_mutexattr_init(&mtxattr);
- pthread_mutexattr_settype(&mtxattr, PTHREAD_MUTEX_RECURSIVE);
- pthread_mutex_init(&mutex->id, &mtxattr);
-
- return (osd_lock *)mutex;
-}
-
-//============================================================
-// osd_lock_acquire
-//============================================================
-
-void osd_lock_acquire(osd_lock *lock)
-{
- hidden_mutex_t *mutex = (hidden_mutex_t *) lock;
- int r;
-
- r = pthread_mutex_lock(&mutex->id);
- if (r==0)
- return;
- //osd_printf_error("Error on lock: %d: %s\n", r, strerror(r));
-}
-
-//============================================================
-// osd_lock_try
-//============================================================
-
-int osd_lock_try(osd_lock *lock)
-{
- hidden_mutex_t *mutex = (hidden_mutex_t *) lock;
- int r;
-
- r = pthread_mutex_trylock(&mutex->id);
- if (r==0)
- return 1;
- //if (r!=EBUSY)
- // osd_printf_error("Error on trylock: %d: %s\n", r, strerror(r));
- return 0;
-}
-
-//============================================================
-// osd_lock_release
-//============================================================
-
-void osd_lock_release(osd_lock *lock)
-{
- hidden_mutex_t *mutex = (hidden_mutex_t *) lock;
-
- pthread_mutex_unlock(&mutex->id);
-}
-
-//============================================================
-// osd_lock_free
-//============================================================
-
-void osd_lock_free(osd_lock *lock)
-{
- hidden_mutex_t *mutex = (hidden_mutex_t *) lock;
-
- //pthread_mutex_unlock(&mutex->id);
- pthread_mutex_destroy(&mutex->id);
- free(mutex);
-}
-
//============================================================
// osd_event_alloc
//============================================================
diff --git a/src/osd/modules/sync/sync_windows.cpp b/src/osd/modules/sync/sync_windows.cpp
index 9439d68b72c..c744f345e6f 100644
--- a/src/osd/modules/sync/sync_windows.cpp
+++ b/src/osd/modules/sync/sync_windows.cpp
@@ -23,8 +23,6 @@
//============================================================
#define DEBUG_SLOW_LOCKS 0
-#define USE_SCALABLE_LOCKS (0)
-
//============================================================
@@ -33,11 +31,6 @@
typedef BOOL (WINAPI *try_enter_critical_section_ptr)(LPCRITICAL_SECTION lpCriticalSection);
-struct osd_lock
-{
- CRITICAL_SECTION critsect;
-};
-
struct osd_event
{
void * ptr;
@@ -49,113 +42,6 @@ struct osd_thread {
void *param;
};
-struct osd_scalable_lock
-{
-#if USE_SCALABLE_LOCKS
- struct
- {
- volatile INT32 haslock; // do we have the lock?
- INT32 filler[64/4-1]; // assumes a 64-byte cache line
- } slot[WORK_MAX_THREADS]; // one slot per thread
- volatile INT32 nextindex; // index of next slot to use
-#else
- CRITICAL_SECTION section;
-#endif
-};
-
-
-//============================================================
-// GLOBAL VARIABLES
-//============================================================
-
-static try_enter_critical_section_ptr try_enter_critical_section = nullptr;
-static int checked_for_try_enter = FALSE;
-
-
-
-//============================================================
-// osd_lock_alloc
-//============================================================
-
-osd_lock *osd_lock_alloc(void)
-{
- osd_lock *lock = (osd_lock *)malloc(sizeof(*lock));
- if (lock == nullptr)
- return nullptr;
- InitializeCriticalSection(&lock->critsect);
- return lock;
-}
-
-
-//============================================================
-// osd_lock_acquire
-//============================================================
-
-void osd_lock_acquire(osd_lock *lock)
-{
-#if DEBUG_SLOW_LOCKS
- osd_ticks_t ticks = osd_ticks();
-#endif
-
- // block until we can acquire the lock
- EnterCriticalSection(&lock->critsect);
-
-#if DEBUG_SLOW_LOCKS
- // log any locks that take more than 1ms
- ticks = osd_ticks() - ticks;
- if (ticks > osd_ticks_per_second() / 1000) osd_printf_debug("Blocked %d ticks on lock acquire\n", (int)ticks);
-#endif
-}
-
-
-//============================================================
-// osd_lock_try
-//============================================================
-
-int osd_lock_try(osd_lock *lock)
-{
- int result = TRUE;
-
- // if we haven't yet checked for the TryEnter API, do it now
- if (!checked_for_try_enter)
- {
- // see if we can use TryEnterCriticalSection
- HMODULE library = LoadLibrary(TEXT("kernel32.dll"));
- if (library != nullptr)
- try_enter_critical_section = (try_enter_critical_section_ptr)GetProcAddress(library, "TryEnterCriticalSection");
- checked_for_try_enter = TRUE;
- }
-
- // if we have it, use it, otherwise just block
- if (try_enter_critical_section != nullptr)
- result = (*try_enter_critical_section)(&lock->critsect);
- else
- EnterCriticalSection(&lock->critsect);
- return result;
-}
-
-
-//============================================================
-// osd_lock_release
-//============================================================
-
-void osd_lock_release(osd_lock *lock)
-{
- LeaveCriticalSection(&lock->critsect);
-}
-
-
-//============================================================
-// osd_lock_free
-//============================================================
-
-void osd_lock_free(osd_lock *lock)
-{
- DeleteCriticalSection(&lock->critsect);
- free(lock);
-}
-
-
//============================================================
// win_compare_exchange32
//============================================================
@@ -317,66 +203,3 @@ int osd_thread_cpu_affinity(osd_thread *thread, UINT32 mask)
{
return TRUE;
}
-
-//============================================================
-// Scalable Locks
-//============================================================
-
-osd_scalable_lock *osd_scalable_lock_alloc(void)
-{
- osd_scalable_lock *lock;
-
- lock = (osd_scalable_lock *)calloc(1, sizeof(*lock));
- if (lock == nullptr)
- return nullptr;
-
- memset(lock, 0, sizeof(*lock));
-#if USE_SCALABLE_LOCKS
- lock->slot[0].haslock = TRUE;
-#else
- InitializeCriticalSection(&lock->section);
-#endif
- return lock;
-}
-
-
-INT32 osd_scalable_lock_acquire(osd_scalable_lock *lock)
-{
-#if USE_SCALABLE_LOCKS
- INT32 myslot = (atomic_increment32(&lock->nextindex) - 1) & (WORK_MAX_THREADS - 1);
- INT32 backoff = 1;
-
- while (!lock->slot[myslot].haslock)
- {
- INT32 backcount;
- for (backcount = 0; backcount < backoff; backcount++)
- osd_yield_processor();
- backoff <<= 1;
- }
- lock->slot[myslot].haslock = FALSE;
- return myslot;
-#else
- EnterCriticalSection(&lock->section);
- return 0;
-#endif
-}
-
-
-void osd_scalable_lock_release(osd_scalable_lock *lock, INT32 myslot)
-{
-#if USE_SCALABLE_LOCKS
- atomic_exchange32(&lock->slot[(myslot + 1) & (WORK_MAX_THREADS - 1)].haslock, TRUE);
-#else
- LeaveCriticalSection(&lock->section);
-#endif
-}
-
-
-void osd_scalable_lock_free(osd_scalable_lock *lock)
-{
-#if USE_SCALABLE_LOCKS
-#else
- DeleteCriticalSection(&lock->section);
-#endif
- free(lock);
-}
diff --git a/src/osd/modules/sync/work_osd.cpp b/src/osd/modules/sync/work_osd.cpp
index e5582584666..2d37feb0c56 100644
--- a/src/osd/modules/sync/work_osd.cpp
+++ b/src/osd/modules/sync/work_osd.cpp
@@ -18,6 +18,7 @@
#include <stdint.h>
#endif
#endif
+#include <mutex>
// MAME headers
#include "osdcore.h"
@@ -109,7 +110,7 @@ struct work_thread_info
struct osd_work_queue
{
- osd_scalable_lock * lock; // lock for protecting the queue
+ std::mutex *lock; // lock for protecting the queue
osd_work_item * volatile list; // list of items in the queue
osd_work_item ** volatile tailptr; // pointer to the tail pointer of work items in the queue
osd_work_item * volatile free; // free list of work items
@@ -188,7 +189,7 @@ osd_work_queue *osd_work_queue_alloc(int flags)
goto error;
// initialize the critical section
- queue->lock = osd_scalable_lock_alloc();
+ queue->lock = new std::mutex();
if (queue->lock == NULL)
goto error;
@@ -421,7 +422,7 @@ void osd_work_queue_free(osd_work_queue *queue)
printf("Spin loops = %9d\n", queue->spinloops);
#endif
- osd_scalable_lock_free(queue->lock);
+ delete queue->lock;
// free the queue itself
osd_free(queue);
}
@@ -435,7 +436,6 @@ osd_work_item *osd_work_item_queue_multiple(osd_work_queue *queue, osd_work_call
{
osd_work_item *itemlist = NULL, *lastitem = NULL;
osd_work_item **item_tailptr = &itemlist;
- INT32 lockslot;
int itemnum;
// loop over items, building up a local list of work
@@ -444,12 +444,13 @@ osd_work_item *osd_work_item_queue_multiple(osd_work_queue *queue, osd_work_call
osd_work_item *item;
// first allocate a new work item; try the free list first
- INT32 myslot = osd_scalable_lock_acquire(queue->lock);
- do
{
- item = (osd_work_item *)queue->free;
- } while (item != NULL && compare_exchange_ptr((PVOID volatile *)&queue->free, item, item->next) != item);
- osd_scalable_lock_release(queue->lock, myslot);
+ std::lock_guard<std::mutex>(*queue->lock);
+ do
+ {
+ item = (osd_work_item *)queue->free;
+ } while (item != NULL && compare_exchange_ptr((PVOID volatile *)&queue->free, item, item->next) != item);
+ }
// if nothing, allocate something new
if (item == NULL)
@@ -482,10 +483,11 @@ osd_work_item *osd_work_item_queue_multiple(osd_work_queue *queue, osd_work_call
}
// enqueue the whole thing within the critical section
- lockslot = osd_scalable_lock_acquire(queue->lock);
- *queue->tailptr = itemlist;
- queue->tailptr = item_tailptr;
- osd_scalable_lock_release(queue->lock, lockslot);
+ {
+ std::lock_guard<std::mutex>(*queue->lock);
+ *queue->tailptr = itemlist;
+ queue->tailptr = item_tailptr;
+ }
// increment the number of items in the queue
atomic_add32(&queue->items, numitems);
@@ -539,9 +541,8 @@ int osd_work_item_wait(osd_work_item *item, osd_ticks_t timeout)
// if we don't have an event, create one
if (item->event == NULL)
{
- INT32 lockslot = osd_scalable_lock_acquire(item->queue->lock);
+ std::lock_guard<std::mutex>(*item->queue->lock);
item->event = osd_event_alloc(TRUE, FALSE); // manual reset, not signalled
- osd_scalable_lock_release(item->queue->lock, lockslot);
}
else
osd_event_reset(item->event);
@@ -584,13 +585,12 @@ void osd_work_item_release(osd_work_item *item)
osd_work_item_wait(item, 100 * osd_ticks_per_second());
// add us to the free list on our queue
- INT32 lockslot = osd_scalable_lock_acquire(item->queue->lock);
+ std::lock_guard<std::mutex>(*item->queue->lock);
do
{
next = (osd_work_item *)item->queue->free;
item->next = next;
} while (compare_exchange_ptr((PVOID volatile *)&item->queue->free, next, item) != next);
- osd_scalable_lock_release(item->queue->lock, lockslot);
}
@@ -711,7 +711,7 @@ static void worker_thread_process(osd_work_queue *queue, work_thread_info *threa
// use a critical section to synchronize the removal of items
{
- INT32 lockslot = osd_scalable_lock_acquire(queue->lock);
+ std::lock_guard<std::mutex>(*queue->lock);
if (queue->list == NULL)
{
end_loop = true;
@@ -727,7 +727,6 @@ static void worker_thread_process(osd_work_queue *queue, work_thread_info *threa
queue->tailptr = (osd_work_item **)&queue->list;
}
}
- osd_scalable_lock_release(queue->lock, lockslot);
}
if (end_loop)
@@ -753,13 +752,12 @@ static void worker_thread_process(osd_work_queue *queue, work_thread_info *threa
// set the result and signal the event
else
{
- INT32 lockslot = osd_scalable_lock_acquire(item->queue->lock);
+ std::lock_guard<std::mutex>(*queue->lock);
if (item->event != NULL)
{
osd_event_set(item->event);
add_to_stat(&item->queue->setevents, 1);
}
- osd_scalable_lock_release(item->queue->lock, lockslot);
}
// if we removed an item and there's still work to do, bump the stats
@@ -780,8 +778,7 @@ static void worker_thread_process(osd_work_queue *queue, work_thread_info *threa
bool queue_has_list_items(osd_work_queue *queue)
{
- INT32 lockslot = osd_scalable_lock_acquire(queue->lock);
+ std::lock_guard<std::mutex>(*queue->lock);
bool has_list_items = (queue->list != NULL);
- osd_scalable_lock_release(queue->lock, lockslot);
return has_list_items;
}
diff --git a/src/osd/osdcore.h b/src/osd/osdcore.h
index 0a4f351e5e9..cd08fa8aa4e 100644
--- a/src/osd/osdcore.h
+++ b/src/osd/osdcore.h
@@ -440,93 +440,6 @@ osd_ticks_t osd_ticks_per_second(void);
-----------------------------------------------------------------------------*/
void osd_sleep(osd_ticks_t duration);
-
-
-/***************************************************************************
- SYNCHRONIZATION INTERFACES
-***************************************************************************/
-
-/* osd_lock is an opaque type which represents a recursive lock/mutex */
-struct osd_lock;
-
-
-/*-----------------------------------------------------------------------------
- osd_lock_alloc: allocate a new lock
-
- Parameters:
-
- None.
-
- Return value:
-
- A pointer to the allocated lock.
------------------------------------------------------------------------------*/
-osd_lock *osd_lock_alloc(void);
-
-
-/*-----------------------------------------------------------------------------
- osd_lock_acquire: acquire a lock, blocking until it can be acquired
-
- Parameters:
-
- lock - a pointer to a previously allocated osd_lock.
-
- Return value:
-
- None.
-
- Notes:
-
- osd_locks are defined to be recursive. If the current thread already
- owns the lock, this function should return immediately.
------------------------------------------------------------------------------*/
-void osd_lock_acquire(osd_lock *lock);
-
-
-/*-----------------------------------------------------------------------------
- osd_lock_try: attempt to acquire a lock
-
- Parameters:
-
- lock - a pointer to a previously allocated osd_lock.
-
- Return value:
-
- TRUE if the lock was available and was acquired successfully.
- FALSE if the lock was already in used by another thread.
------------------------------------------------------------------------------*/
-int osd_lock_try(osd_lock *lock);
-
-
-/*-----------------------------------------------------------------------------
- osd_lock_release: release control of a lock that has been acquired
-
- Parameters:
-
- lock - a pointer to a previously allocated osd_lock.
-
- Return value:
-
- None.
------------------------------------------------------------------------------*/
-void osd_lock_release(osd_lock *lock);
-
-
-/*-----------------------------------------------------------------------------
- osd_lock_free: free the memory and resources associated with an osd_lock
-
- Parameters:
-
- lock - a pointer to a previously allocated osd_lock.
-
- Return value:
-
- None.
------------------------------------------------------------------------------*/
-void osd_lock_free(osd_lock *lock);
-
-
-
/***************************************************************************
WORK ITEM INTERFACES
***************************************************************************/
diff --git a/src/osd/osdmini/minisync.cpp b/src/osd/osdmini/minisync.cpp
deleted file mode 100644
index a78765f29ed..00000000000
--- a/src/osd/osdmini/minisync.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-// license:BSD-3-Clause
-// copyright-holders:Aaron Giles
-//============================================================
-//
-// minisync.c - Minimal core synchronization functions
-//
-//============================================================
-
-#include "osdcore.h"
-
-
-//============================================================
-// osd_lock_alloc
-//============================================================
-
-osd_lock *osd_lock_alloc(void)
-{
- // the minimal implementation does not support threading
- // just return a dummy value here
- return (osd_lock *)1;
-}
-
-
-//============================================================
-// osd_lock_acquire
-//============================================================
-
-void osd_lock_acquire(osd_lock *lock)
-{
- // the minimal implementation does not support threading
- // the acquire always "succeeds"
-}
-
-
-//============================================================
-// osd_lock_try
-//============================================================
-
-int osd_lock_try(osd_lock *lock)
-{
- // the minimal implementation does not support threading
- // the acquire always "succeeds"
- return TRUE;
-}
-
-
-//============================================================
-// osd_lock_release
-//============================================================
-
-void osd_lock_release(osd_lock *lock)
-{
- // the minimal implementation does not support threading
- // do nothing here
-}
-
-
-//============================================================
-// osd_lock_free
-//============================================================
-
-void osd_lock_free(osd_lock *lock)
-{
- // the minimal implementation does not support threading
- // do nothing here
-}
diff --git a/src/osd/sdl/input.cpp b/src/osd/sdl/input.cpp
index 4dfb5bd0ad0..b0d4d8c1096 100644
--- a/src/osd/sdl/input.cpp
+++ b/src/osd/sdl/input.cpp
@@ -15,6 +15,7 @@
#include "sdlinc.h"
#include <ctype.h>
#include <stddef.h>
+#include <mutex>
#if USE_XINPUT
// for xinput
@@ -154,7 +155,7 @@ struct device_info
//============================================================
// global states
-static osd_lock * input_lock;
+static std::mutex input_lock;
static UINT8 input_paused;
static sdl_window_info * focus_window = NULL;
@@ -1380,10 +1381,6 @@ bool sdl_osd_interface::input_init()
app_has_mouse_focus = 1;
- // allocate a lock for input synchronizations
- input_lock = osd_lock_alloc();
- assert_always(input_lock != NULL, "Failed to allocate input_lock");
-
// register the keyboards
sdlinput_register_keyboards(machine());
@@ -1441,9 +1438,6 @@ void sdl_osd_interface::input_resume()
void sdl_osd_interface::input_exit()
{
- // free the lock
- osd_lock_free(input_lock);
-
// deregister
sdlinput_deregister_joysticks(machine());
@@ -1568,7 +1562,7 @@ void sdlinput_process_events_buf()
if (SDLMAME_EVENTS_IN_WORKER_THREAD)
{
- osd_lock_acquire(input_lock);
+ std::lock_guard<std::mutex> lock(input_lock);
#if (SDLMAME_SDL2)
/* Make sure we get all pending events */
SDL_PumpEvents();
@@ -1580,7 +1574,6 @@ void sdlinput_process_events_buf()
else
osd_printf_warning("Event Buffer Overflow!\n");
}
- osd_lock_release(input_lock);
}
else
SDL_PumpEvents();
@@ -1709,11 +1702,10 @@ void sdlinput_poll(running_machine &machine)
if (SDLMAME_EVENTS_IN_WORKER_THREAD)
{
- osd_lock_acquire(input_lock);
+ std::lock_guard<std::mutex> lock(input_lock);
memcpy(loc_event_buf, event_buf, sizeof(event_buf));
loc_event_buf_count = event_buf_count;
event_buf_count = 0;
- osd_lock_release(input_lock);
bufp = 0;
}
diff --git a/src/osd/windows/input.cpp b/src/osd/windows/input.cpp
index 77adda7a2ca..9157036ffd5 100644
--- a/src/osd/windows/input.cpp
+++ b/src/osd/windows/input.cpp
@@ -39,6 +39,7 @@
#include "config.h"
#include "winutil.h"
+#include <mutex>
//============================================================
// PARAMETERS
@@ -166,7 +167,7 @@ typedef /*WINUSERAPI*/ BOOL (WINAPI *register_rawinput_devices_ptr)(IN PCRAWINPU
// global states
static bool input_enabled;
-static osd_lock * input_lock;
+static std::mutex input_lock;
static bool input_paused;
static DWORD last_poll;
@@ -469,10 +470,6 @@ static inline INT32 normalize_absolute_axis(INT32 raw, INT32 rawmin, INT32 rawma
bool windows_osd_interface::input_init()
{
- // allocate a lock for input synchronizations, since messages sometimes come from another thread
- input_lock = osd_lock_alloc();
- assert_always(input_lock != NULL, "Failed to allocate input_lock");
-
// decode the options
lightgun_shared_axis_mode = downcast<windows_options &>(machine().options()).dual_lightgun();
@@ -512,15 +509,8 @@ void windows_osd_interface::input_resume()
void windows_osd_interface::input_exit()
{
// acquire the lock and turn off input (this ensures everyone is done)
- if (input_lock != NULL)
- {
- osd_lock_acquire(input_lock);
- input_enabled = false;
- osd_lock_release(input_lock);
-
- // free the lock
- osd_lock_free(input_lock);
- }
+ std::lock_guard<std::mutex> lock(input_lock);
+ input_enabled = false;
}
@@ -613,7 +603,7 @@ BOOL wininput_handle_mouse_button(int button, int down, int x, int y)
}
// take the lock
- osd_lock_acquire(input_lock);
+ std::lock_guard<std::mutex> lock(input_lock);
// set the button state
devinfo->mouse.state.rgbButtons[button] = down ? 0x80 : 0x00;
@@ -632,9 +622,6 @@ BOOL wininput_handle_mouse_button(int button, int down, int x, int y)
devinfo->mouse.state.lX = normalize_absolute_axis(mousepos.x, client_rect.left, client_rect.right);
devinfo->mouse.state.lY = normalize_absolute_axis(mousepos.y, client_rect.top, client_rect.bottom);
}
-
- // release the lock
- osd_lock_release(input_lock);
return TRUE;
}
@@ -675,18 +662,16 @@ BOOL wininput_handle_raw(HANDLE device)
// handle keyboard input
if (input->header.dwType == RIM_TYPEKEYBOARD)
{
- osd_lock_acquire(input_lock);
+ std::lock_guard<std::mutex> lock(input_lock);
rawinput_keyboard_update(input->header.hDevice, &input->data.keyboard);
- osd_lock_release(input_lock);
result = TRUE;
}
// handle mouse input
else if (input->header.dwType == RIM_TYPEMOUSE)
{
- osd_lock_acquire(input_lock);
+ std::lock_guard<std::mutex> lock(input_lock);
rawinput_mouse_update(input->header.hDevice, &input->data.mouse);
- osd_lock_release(input_lock);
result = TRUE;
}
}
@@ -2201,14 +2186,13 @@ static void rawinput_mouse_poll(device_info *devinfo)
poll_if_necessary(devinfo->machine());
// copy the accumulated raw state to the actual state
- osd_lock_acquire(input_lock);
+ std::lock_guard<std::mutex> lock(input_lock);
devinfo->mouse.state.lX = devinfo->mouse.raw_x;
devinfo->mouse.state.lY = devinfo->mouse.raw_y;
devinfo->mouse.state.lZ = devinfo->mouse.raw_z;
devinfo->mouse.raw_x = 0;
devinfo->mouse.raw_y = 0;
devinfo->mouse.raw_z = 0;
- osd_lock_release(input_lock);
}
diff --git a/src/osd/windows/window.cpp b/src/osd/windows/window.cpp
index 6111859a255..046211d4f29 100644
--- a/src/osd/windows/window.cpp
+++ b/src/osd/windows/window.cpp
@@ -300,7 +300,6 @@ win_window_info::win_window_info(running_machine &machine)
m_fullscreen(0),
m_fullscreen_safe(0),
m_aspect(0),
- m_render_lock(NULL),
m_target(NULL),
m_targetview(0),
m_targetorient(0),
@@ -672,9 +671,6 @@ void win_window_info::create(running_machine &machine, int index, osd_monitor_in
*last_window_ptr = window;
last_window_ptr = &window->m_next;
- // create a lock that we can use to skip blitting
- window->m_render_lock = osd_lock_alloc();
-
// load the layout
window->m_target = machine.render().target_alloc();
@@ -746,11 +742,6 @@ void win_window_info::destroy()
// free the render target
machine().render().target_free(m_target);
-
- // FIXME: move to destructor
- // free the lock
- osd_lock_free(m_render_lock);
-
}
@@ -798,9 +789,9 @@ void win_window_info::update()
// only block if we're throttled
if (machine().video().throttled() || timeGetTime() - last_update_time > 250)
- osd_lock_acquire(m_render_lock);
+ m_render_lock.lock();
else
- got_lock = osd_lock_try(m_render_lock);
+ got_lock = m_render_lock.try_lock();
// only render if we were able to get the lock
if (got_lock)
@@ -810,7 +801,7 @@ void win_window_info::update()
mtlog_add("winwindow_video_window_update: got lock");
// don't hold the lock; we just used it to see if rendering was still happening
- osd_lock_release(m_render_lock);
+ m_render_lock.unlock();
// ensure the target bounds are up-to-date, and then get the primitives
primlist = m_renderer->get_primitives();
@@ -1492,7 +1483,7 @@ void win_window_info::draw_video_contents(HDC dc, int update)
mtlog_add("draw_video_contents: begin");
mtlog_add("draw_video_contents: render lock acquire");
- osd_lock_acquire(m_render_lock);
+ std::lock_guard<std::mutex> lock(m_render_lock);
mtlog_add("draw_video_contents: render lock acquired");
// if we're iconic, don't bother
@@ -1516,7 +1507,6 @@ void win_window_info::draw_video_contents(HDC dc, int update)
}
}
- osd_lock_release(m_render_lock);
mtlog_add("draw_video_contents: render lock released");
mtlog_add("draw_video_contents: end");
diff --git a/src/osd/windows/window.h b/src/osd/windows/window.h
index 62d4f57db55..6a925494f93 100644
--- a/src/osd/windows/window.h
+++ b/src/osd/windows/window.h
@@ -9,6 +9,7 @@
#ifndef __WIN_WINDOW__
#define __WIN_WINDOW__
+#include <mutex>
#include "video.h"
#include "render.h"
@@ -92,7 +93,7 @@ public:
float m_aspect;
// rendering info
- osd_lock * m_render_lock;
+ std::mutex m_render_lock;
render_target * m_target;
int m_targetview;
int m_targetorient;