diff options
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; |
