dlls/msvcp140_atomic_wait/main.c

   1 /*
   2  * Copyright 2022 Daniel Lehman
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include "windef.h"
  21 #include "winbase.h"
  22 #include "wine/debug.h"
  23 #include "wine/list.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(msvcp);
  26
  27 extern unsigned int __cdecl _Thrd_hardware_concurrency(void);
  28
  29 unsigned int __stdcall __std_parallel_algorithms_hw_threads(void)
  30 {
  31     TRACE("()\n");
  32     return _Thrd_hardware_concurrency();
  33 }
  34
  35 void __stdcall __std_bulk_submit_threadpool_work(PTP_WORK work, size_t count)
  36 {
  37     TRACE("(%p %Iu)\n", work, count);
  38     while (count--)
  39         SubmitThreadpoolWork(work);
  40 }
  41
  42 void __stdcall __std_close_threadpool_work(PTP_WORK work)
  43 {
  44     TRACE("(%p)\n", work);
  45     return CloseThreadpoolWork(work);
  46 }
  47
  48 PTP_WORK __stdcall __std_create_threadpool_work(PTP_WORK_CALLBACK callback, void *context,
  49                                                 PTP_CALLBACK_ENVIRON environ)
  50 {
  51     TRACE("(%p %p %p)\n", callback, context, environ);
  52     return CreateThreadpoolWork(callback, context, environ);
  53 }
  54
  55 void __stdcall __std_submit_threadpool_work(PTP_WORK work)
  56 {
  57     TRACE("(%p)\n", work);
  58     return SubmitThreadpoolWork(work);
  59 }
  60
  61 void __stdcall __std_wait_for_threadpool_work_callbacks(PTP_WORK work, BOOL cancel)
  62 {
  63     TRACE("(%p %d)\n", work, cancel);
  64     return WaitForThreadpoolWorkCallbacks(work, cancel);
  65 }
  66
  67 void __stdcall __std_atomic_notify_one_direct(void *addr)
  68 {
  69     TRACE("(%p)\n", addr);
  70     WakeByAddressSingle(addr);
  71 }
  72
  73 void __stdcall __std_atomic_notify_all_direct(void *addr)
  74 {
  75     TRACE("(%p)\n", addr);
  76     WakeByAddressAll(addr);
  77 }
  78
  79 BOOL __stdcall __std_atomic_wait_direct(volatile void *addr, void *cmp,
  80                                         SIZE_T size, DWORD timeout)
  81 {
  82     TRACE("(%p %p %Id %ld)\n", addr, cmp, size, timeout);
  83     return WaitOnAddress(addr, cmp, size, timeout);
  84 }
  85
  86 typedef struct
  87 {
  88     SRWLOCK srwlock;
  89 } shared_mutex;
  90
  91 struct shared_mutex_elem
  92 {
  93     struct list entry;
  94     int ref;
  95     void *ptr;
  96     shared_mutex mutex;
  97 };
  98
  99 static CRITICAL_SECTION shared_mutex_cs;
 100 static CRITICAL_SECTION_DEBUG shared_mutex_cs_debug =
 101 {
 102     0, 0, &shared_mutex_cs,
 103     { &shared_mutex_cs_debug.ProcessLocksList, &shared_mutex_cs_debug.ProcessLocksList },
 104       0, 0, { (DWORD_PTR)(__FILE__ ": shared_mutex_cs") }
 105 };
 106 static CRITICAL_SECTION shared_mutex_cs = { &shared_mutex_cs_debug, -1, 0, 0, 0, 0 };
 107 static struct list shared_mutex_list = LIST_INIT(shared_mutex_list);
 108
 109 /* shared_mutex_cs must be held by caller */
 110 static struct shared_mutex_elem* find_shared_mutex(void *ptr)
 111 {
 112     struct shared_mutex_elem *sme;
 113
 114     LIST_FOR_EACH_ENTRY(sme, &shared_mutex_list, struct shared_mutex_elem, entry)
 115     {
 116         if (sme->ptr == ptr)
 117             return sme;
 118     }
 119     return NULL;
 120 }
 121
 122 shared_mutex* __stdcall __std_acquire_shared_mutex_for_instance(void *ptr)
 123 {
 124     struct shared_mutex_elem *sme;
 125
 126     TRACE("(%p)\n", ptr);
 127
 128     EnterCriticalSection(&shared_mutex_cs);
 129     sme = find_shared_mutex(ptr);
 130     if (sme)
 131     {
 132         sme->ref++;
 133         LeaveCriticalSection(&shared_mutex_cs);
 134         return &sme->mutex;
 135     }
 136
 137     sme = malloc(sizeof(*sme));
 138     sme->ref = 1;
 139     sme->ptr = ptr;
 140     InitializeSRWLock(&sme->mutex.srwlock);
 141     list_add_head(&shared_mutex_list, &sme->entry);
 142     LeaveCriticalSection(&shared_mutex_cs);
 143     return &sme->mutex;
 144 }
 145
 146 void __stdcall __std_release_shared_mutex_for_instance(void *ptr)
 147 {
 148     struct shared_mutex_elem *sme;
 149
 150     TRACE("(%p)\n", ptr);
 151
 152     EnterCriticalSection(&shared_mutex_cs);
 153     sme = find_shared_mutex(ptr);
 154     if (!sme)
 155     {
 156         LeaveCriticalSection(&shared_mutex_cs);
 157         return;
 158     }
 159
 160     sme->ref--;
 161     if (!sme->ref)
 162     {
 163         list_remove(&sme->entry);
 164         free(sme);
 165     }
 166     LeaveCriticalSection(&shared_mutex_cs);
 167 }