summaryrefslogtreecommitdiffstatshomepage
path: root/src/osd/modules/sync/osdsync.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/osd/modules/sync/osdsync.h')
-rw-r--r--src/osd/modules/sync/osdsync.h200
1 files changed, 200 insertions, 0 deletions
diff --git a/src/osd/modules/sync/osdsync.h b/src/osd/modules/sync/osdsync.h
new file mode 100644
index 00000000000..5d166eb5145
--- /dev/null
+++ b/src/osd/modules/sync/osdsync.h
@@ -0,0 +1,200 @@
+//============================================================
+//
+// winsync.h - Windows core synchronization functions
+//
+// Copyright (c) 1996-2014, Nicola Salmoria and the MAME Team.
+// Visit http://mamedev.org for licensing and usage restrictions.
+//
+//============================================================
+
+#ifndef __OSDSYNC__
+#define __OSDSYNC__
+
+/***************************************************************************
+ SYNCHRONIZATION INTERFACES - Events
+***************************************************************************/
+
+/* osd_event is an opaque type which represents a setable/resetable event */
+
+struct osd_event;
+
+
+/*-----------------------------------------------------------------------------
+ osd_lock_event_alloc: allocate a new event
+
+ Parameters:
+
+ manualreset - boolean. If true, the event will be automatically set
+ to non-signalled after a thread successfully waited for
+ it.
+ initialstate - boolean. If true, the event is signalled initially.
+
+ Return value:
+
+ A pointer to the allocated event.
+-----------------------------------------------------------------------------*/
+osd_event *osd_event_alloc(int manualreset, int initialstate);
+
+
+/*-----------------------------------------------------------------------------
+ osd_event_wait: wait for an event to be signalled
+
+ Parameters:
+
+ event - The event to wait for. If the event is in signalled state, the
+ function returns immediately. If not it will wait for the event
+ to become signalled.
+ timeout - timeout in osd_ticks
+
+ Return value:
+
+ TRUE: The event was signalled
+ FALSE: A timeout occurred
+-----------------------------------------------------------------------------*/
+int osd_event_wait(osd_event *event, osd_ticks_t timeout);
+
+
+/*-----------------------------------------------------------------------------
+ osd_event_reset: reset an event to non-signalled state
+
+ Parameters:
+
+ event - The event to set to non-signalled state
+
+ Return value:
+
+ None
+-----------------------------------------------------------------------------*/
+void osd_event_reset(osd_event *event);
+
+
+/*-----------------------------------------------------------------------------
+ osd_event_set: set an event to signalled state
+
+ Parameters:
+
+ event - The event to set to signalled state
+
+ Return value:
+
+ None
+
+ Notes:
+
+ All threads waiting for the event will be signalled.
+-----------------------------------------------------------------------------*/
+void osd_event_set(osd_event *event);
+
+
+/*-----------------------------------------------------------------------------
+ osd_event_free: free the memory and resources associated with an osd_event
+
+ Parameters:
+
+ event - a pointer to a previously allocated osd_event.
+
+ Return value:
+
+ None.
+-----------------------------------------------------------------------------*/
+void osd_event_free(osd_event *event);
+
+/***************************************************************************
+ SYNCHRONIZATION INTERFACES - Threads
+***************************************************************************/
+
+/* osd_thread is an opaque type which represents a thread */
+struct osd_thread;
+
+
+/* osd_thread_callback is a callback function that will be called from the thread */
+typedef void *(*osd_thread_callback)(void *param);
+
+
+/*-----------------------------------------------------------------------------
+ osd_thread_create: create a new thread
+
+ Parameters:
+
+ callback - The callback function to be called once the thread is up
+ cbparam - The parameter to pass to the callback function.
+
+ Return value:
+
+ A pointer to the created thread.
+-----------------------------------------------------------------------------*/
+osd_thread *osd_thread_create(osd_thread_callback callback, void *cbparam);
+
+/*-----------------------------------------------------------------------------
+ osd_thread_adjust_priority: adjust priority of a thread
+
+ Parameters:
+
+ thread - A pointer to a previously created thread.
+ adjust - signed integer to add to the thread priority
+
+ Return value:
+
+ TRUE on success, FALSE on failure
+-----------------------------------------------------------------------------*/
+int osd_thread_adjust_priority(osd_thread *thread, int adjust);
+
+
+/*-----------------------------------------------------------------------------
+ osd_thread_cpu_affinity: change cpu affinity of a thread
+
+ Parameters:
+
+ thread - A pointer to a previously created thread
+ or NULL for main thread
+ mask - bitmask to which cpus to bind
+ i.e. 0x01 1st cpu, 0x02, 2nd cpu, 0x04 3rd cpu
+
+ Return value:
+
+ TRUE on success, FALSE on failure
+-----------------------------------------------------------------------------*/
+int osd_thread_cpu_affinity(osd_thread *thread, UINT32 mask);
+
+
+/*-----------------------------------------------------------------------------
+ osd_thread_wait_free: wait for thread to finish and free resources
+
+ Parameters:
+
+ thread - A pointer to a previously created thread.
+
+ Return value:
+
+ None.
+-----------------------------------------------------------------------------*/
+void osd_thread_wait_free(osd_thread *thread);
+
+/*-----------------------------------------------------------------------------
+ osd_process_kill: kill the current process
+
+ Parameters:
+
+ None.
+
+ Return value:
+
+ None.
+-----------------------------------------------------------------------------*/
+void osd_process_kill(void);
+
+//============================================================
+// 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__ */