erts: Replace usage of all erts_smp prefixes to just erts

5 files changed, 57 insertions, 57 deletions

diff --git a/erts/emulator/sys/win32/erl_poll.c b/erts/emulator/sys/win32/erl_poll.c
index 41ff186c44..0bd43bb4fb 100644
--- a/erts/emulator/sys/win32/erl_poll.c
+++ b/erts/emulator/sys/win32/erl_poll.c
@@ -286,26 +286,26 @@ struct ErtsPollSet_ {
     CRITICAL_SECTION standby_crit;     /* CS to guard the counter */
     HANDLE standby_wait_event;         /* Event signalled when counte == 0 */
     erts_atomic32_t wakeup_state;
-    erts_smp_mtx_t mtx;
+    erts_mtx_t mtx;
     erts_atomic64_t timeout_time;
 };
 
 
 #define ERTS_POLLSET_LOCK(PS) \
-  erts_smp_mtx_lock(&(PS)->mtx)
+  erts_mtx_lock(&(PS)->mtx)
 #define ERTS_POLLSET_UNLOCK(PS) \
-  erts_smp_mtx_unlock(&(PS)->mtx)
+  erts_mtx_unlock(&(PS)->mtx)
 
 
 /*
  * Communication with sys_interrupt
  */
 
-extern erts_smp_atomic32_t erts_break_requested;
+extern erts_atomic32_t erts_break_requested;
 #define ERTS_SET_BREAK_REQUESTED \
-  erts_smp_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 1)
+  erts_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 1)
 #define ERTS_UNSET_BREAK_REQUESTED \
-  erts_smp_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 0)
+  erts_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 0)
 
 static erts_mtx_t break_waiter_lock;
 static HANDLE break_happened_event;
@@ -1340,7 +1340,7 @@ ErtsPollSet erts_poll_create_pollset(void)
     ps->restore_events = 0;
 
     erts_atomic32_init_nob(&ps->wakeup_state, ERTS_POLL_NOT_WOKEN);
-    erts_smp_mtx_init(&ps->mtx, "pollset", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
+    erts_mtx_init(&ps->mtx, "pollset", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
     init_timeout_time(ps);
 
     HARDTRACEF(("Out erts_poll_create_pollset"));
@@ -1370,7 +1370,7 @@ void erts_poll_destroy_pollset(ErtsPollSet ps)
     CloseHandle(ps->event_io_ready);
     CloseHandle(ps->standby_wait_event);
     ERTS_POLLSET_UNLOCK(ps);
-    erts_smp_mtx_destroy(&ps->mtx);
+    erts_mtx_destroy(&ps->mtx);
     SEL_FREE(ERTS_ALC_T_POLLSET, (void *) ps);
     HARDTRACEF(("Out erts_poll_destroy_pollset"));
 }
diff --git a/erts/emulator/sys/win32/sys.c b/erts/emulator/sys/win32/sys.c
index 4c06535e4e..b23dbecbac 100644
--- a/erts/emulator/sys/win32/sys.c
+++ b/erts/emulator/sys/win32/sys.c
@@ -80,9 +80,9 @@ static int application_type(const wchar_t* originalName, wchar_t fullPath[MAX_PA
 
 HANDLE erts_service_event;
 
-static erts_smp_tsd_key_t win32_errstr_key;
+static erts_tsd_key_t win32_errstr_key;
 
-static erts_smp_atomic_t pipe_creation_counter;
+static erts_atomic_t pipe_creation_counter;
 
 /* Results from application_type(_w) is one of */
 #define APPL_NONE 0
@@ -141,7 +141,7 @@ static BOOL (WINAPI *fpCancelIoEx)(HANDLE,LPOVERLAPPED);
    - call erl_start() to parse arguments and do other init
 */
 
-static erts_smp_atomic_t sys_misc_mem_sz;
+static erts_atomic_t sys_misc_mem_sz;
 
 HMODULE beam_module = NULL;
 
@@ -192,7 +192,7 @@ Uint
 erts_sys_misc_mem_sz(void)
 {
     Uint res = (Uint) erts_check_io_size();
-    res += (Uint) erts_smp_atomic_read_mb(&sys_misc_mem_sz);
+    res += (Uint) erts_atomic_read_mb(&sys_misc_mem_sz);
     return res;
 }
 
@@ -659,7 +659,7 @@ new_driver_data(ErlDrvPort port_num, int packet_bytes, int wait_objs_required, i
     dp->inbuf = DRV_BUF_ALLOC(dp->inBufSize);
     if (dp->inbuf == NULL)
 	goto buf_alloc_error;
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz, dp->inBufSize);
+    erts_atomic_add_nob(&sys_misc_mem_sz, dp->inBufSize);
     dp->outBufSize = 0;
     dp->outbuf = NULL;
     dp->port_num = port_num;
@@ -729,8 +729,8 @@ release_driver_data(DriverData* dp)
     }
 
     if (dp->inbuf != NULL) {
-	ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->inBufSize);
-	erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*dp->inBufSize);
+	ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= dp->inBufSize);
+	erts_atomic_add_nob(&sys_misc_mem_sz, -1*dp->inBufSize);
 	DRV_BUF_FREE(dp->inbuf);
 	dp->inBufSize = 0;
 	dp->inbuf = NULL;
@@ -738,8 +738,8 @@ release_driver_data(DriverData* dp)
     ASSERT(dp->inBufSize == 0);
 
     if (dp->outbuf != NULL) {
-	ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
-	erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
+	ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
+	erts_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
 	DRV_BUF_FREE(dp->outbuf);
 	dp->outBufSize = 0;
 	dp->outbuf = NULL;
@@ -1737,7 +1737,7 @@ static int create_pipe(HANDLE *phRead, HANDLE *phWrite, BOOL inheritRead, BOOL o
      * Otherwise, create named pipes.
      */
 
-    calls = (UWord) erts_smp_atomic_inc_read_nob(&pipe_creation_counter);
+    calls = (UWord) erts_atomic_inc_read_nob(&pipe_creation_counter);
     erts_snprintf(pipe_name, sizeof(pipe_name),
 		  "\\\\.\\pipe\\erlang44_%d_%bpu", getpid(), calls);
 
@@ -2422,7 +2422,7 @@ output(ErlDrvData drv_data, char* buf, ErlDrvSizeT len)
     }
 
     dp->outBufSize = pb+len;
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz, dp->outBufSize);
+    erts_atomic_add_nob(&sys_misc_mem_sz, dp->outBufSize);
 
     /*
      * Store header bytes (if any).
@@ -2451,8 +2451,8 @@ output(ErlDrvData drv_data, char* buf, ErlDrvSizeT len)
     } else {
 	dp->out.ov.Offset += pb+len; /* For vanilla driver. */
 	/* XXX OffsetHigh should be changed too. */
-	ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
-	erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
+	ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
+	erts_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
 	DRV_BUF_FREE(dp->outbuf);
 	dp->outBufSize = 0;
 	dp->outbuf = NULL;
@@ -2563,8 +2563,8 @@ ready_input(ErlDrvData drv_data, ErlDrvEvent ready_event)
 			    error = ERROR_NOT_ENOUGH_MEMORY;
 			    break; /* Break out of loop into error handler. */
 			}
-			ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->inBufSize);
-			erts_smp_atomic_add_nob(&sys_misc_mem_sz,
+			ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= dp->inBufSize);
+			erts_atomic_add_nob(&sys_misc_mem_sz,
 						dp->totalNeeded - dp->inBufSize);
 			dp->inBufSize = dp->totalNeeded;
 			dp->inbuf = new_buf;
@@ -2663,8 +2663,8 @@ ready_output(ErlDrvData drv_data, ErlDrvEvent ready_event)
 	   write... */
 	return;
     }
-    ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
+    ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
+    erts_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
     DRV_BUF_FREE(dp->outbuf);
     dp->outBufSize = 0;
     dp->outbuf = NULL;
@@ -2812,7 +2812,7 @@ Preload* sys_preloaded(void)
 			   (num_preloaded+1)*sizeof(Preload));
     res_name = erts_alloc(ERTS_ALC_T_PRELOADED,
 			  (num_preloaded+1)*sizeof(unsigned));
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz,
+    erts_atomic_add_nob(&sys_misc_mem_sz,
 			    (num_preloaded+1)*sizeof(Preload)
 			    + (num_preloaded+1)*sizeof(unsigned));
     for (i = 0; i < num_preloaded; i++) {
@@ -2825,7 +2825,7 @@ Preload* sys_preloaded(void)
 	n = GETWORD(data);
 	data += 2;
 	preloaded[i].name = erts_alloc(ERTS_ALC_T_PRELOADED, n+1);
-	erts_smp_atomic_add_nob(&sys_misc_mem_sz, n+1);
+	erts_atomic_add_nob(&sys_misc_mem_sz, n+1);
 	sys_memcpy(preloaded[i].name, data, n);
 	preloaded[i].name[n] = '\0';
 	data += n;
@@ -2907,7 +2907,7 @@ sys_get_key(int fd)
 
 char* win32_errorstr(int error)
 {
-  LPTSTR lpBufPtr = erts_smp_tsd_get(win32_errstr_key);
+  LPTSTR lpBufPtr = erts_tsd_get(win32_errstr_key);
   if (lpBufPtr) {
       LocalFree(lpBufPtr);
   }
@@ -2921,7 +2921,7 @@ char* win32_errorstr(int error)
 		0,
 		NULL);
   SetLastError(error);
-  erts_smp_tsd_set(win32_errstr_key,lpBufPtr);
+  erts_tsd_set(win32_errstr_key,lpBufPtr);
   return lpBufPtr;
 }
 
@@ -3170,7 +3170,7 @@ erts_sys_pre_init(void)
 
     erts_init_sys_time_sup();
 
-    erts_smp_atomic_init_nob(&sys_misc_mem_sz, 0);
+    erts_atomic_init_nob(&sys_misc_mem_sz, 0);
 }
 
 void noinherit_std_handle(DWORD type)
@@ -3190,9 +3190,9 @@ void erl_sys_init(void)
     noinherit_std_handle(STD_INPUT_HANDLE);
     noinherit_std_handle(STD_ERROR_HANDLE);
 
-    erts_smp_tsd_key_create(&win32_errstr_key,"win32_errstr_key");
+    erts_tsd_key_create(&win32_errstr_key,"win32_errstr_key");
     InitializeCriticalSection(&htbc_lock);
-    erts_smp_atomic_init_nob(&pipe_creation_counter,0);
+    erts_atomic_init_nob(&pipe_creation_counter,0);
     /*
      * Test if we have named pipes or not.
      */
@@ -3269,6 +3269,6 @@ void
 erl_sys_schedule(int runnable)
 {
     erts_check_io(!runnable);
-    ERTS_SMP_LC_ASSERT(!erts_thr_progress_is_blocking());
+    ERTS_LC_ASSERT(!erts_thr_progress_is_blocking());
 }
 
diff --git a/erts/emulator/sys/win32/sys_env.c b/erts/emulator/sys/win32/sys_env.c
index 8fcee1cbb6..5792816267 100644
--- a/erts/emulator/sys/win32/sys_env.c
+++ b/erts/emulator/sys/win32/sys_env.c
@@ -32,12 +32,12 @@ static WCHAR **env_to_arg(WCHAR *env);
 static WCHAR **find_arg(WCHAR **arg, WCHAR *str);

 static int compare(const void *a, const void *b);

 

-static erts_smp_rwmtx_t environ_rwmtx;

+static erts_rwmtx_t environ_rwmtx;
 

 void

 erts_sys_env_init(void)

 {

-    erts_smp_rwmtx_init(&environ_rwmtx, "environ", NIL,

+    erts_rwmtx_init(&environ_rwmtx, "environ", NIL,
         ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);

 }

 

@@ -45,10 +45,10 @@ int
 erts_sys_putenv_raw(char *key, char *value)

 {

     int res;

-    erts_smp_rwmtx_rwlock(&environ_rwmtx);

+    erts_rwmtx_rwlock(&environ_rwmtx);
     res = (SetEnvironmentVariable((LPCTSTR) key,

 				  (LPCTSTR) value) ? 0 : 1);

-    erts_smp_rwmtx_rwunlock(&environ_rwmtx);

+    erts_rwmtx_rwunlock(&environ_rwmtx);
     return res;

 }

 

@@ -58,10 +58,10 @@ erts_sys_putenv(char *key, char *value)
     int res;

     WCHAR *wkey = (WCHAR *) key;

     WCHAR *wvalue = (WCHAR *) value;

-    erts_smp_rwmtx_rwlock(&environ_rwmtx);

+    erts_rwmtx_rwlock(&environ_rwmtx);
     res = (SetEnvironmentVariableW(wkey,

 				   wvalue) ? 0 : 1);

-    erts_smp_rwmtx_rwunlock(&environ_rwmtx);

+    erts_rwmtx_rwunlock(&environ_rwmtx);
     return res;

 }

 

@@ -76,12 +76,12 @@ erts_sys_getenv(char *key, char *value, size_t *size)
     DWORD wsize = *size / (sizeof(WCHAR) / sizeof(char));

 

     SetLastError(0);

-    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    erts_rwmtx_rlock(&environ_rwmtx);
     new_size = GetEnvironmentVariableW(wkey,

 				       wvalue,

 				      (DWORD) wsize);

     res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;

-    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    erts_rwmtx_runlock(&environ_rwmtx);
     if (res < 0)

 	return res;

     res = new_size > wsize ? 1 : 0;

@@ -111,22 +111,22 @@ int
 erts_sys_getenv_raw(char *key, char *value, size_t *size)

 {

     int res;

-    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    erts_rwmtx_rlock(&environ_rwmtx);
     res = erts_sys_getenv__(key, value, size);

-    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    erts_rwmtx_runlock(&environ_rwmtx);
     return res;

 }

 

 void init_getenv_state(GETENV_STATE *state)

 {

-    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    erts_rwmtx_rlock(&environ_rwmtx);
     state->environment_strings = GetEnvironmentStringsW();

     state->next_string = state->environment_strings;

 }

 

 char *getenv_string(GETENV_STATE *state)

 {

-    ERTS_SMP_LC_ASSERT(erts_smp_lc_rwmtx_is_rlocked(&environ_rwmtx));

+    ERTS_LC_ASSERT(erts_lc_rwmtx_is_rlocked(&environ_rwmtx));
     if (state->next_string[0] == L'\0') {

 	return NULL;

     } else {

@@ -140,7 +140,7 @@ void fini_getenv_state(GETENV_STATE *state)
 {

     FreeEnvironmentStringsW(state->environment_strings);

     state->environment_strings = state->next_string = NULL;

-    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    erts_rwmtx_runlock(&environ_rwmtx);
 }

 

 int erts_sys_unsetenv(char *key)

@@ -149,7 +149,7 @@ int erts_sys_unsetenv(char *key)
     WCHAR *wkey = (WCHAR *) key;

 

     SetLastError(0);

-    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    erts_rwmtx_rlock(&environ_rwmtx);
     GetEnvironmentVariableW(wkey,

                             NULL,

                             0);

@@ -157,7 +157,7 @@ int erts_sys_unsetenv(char *key)
         res = (SetEnvironmentVariableW(wkey,

                                        NULL) ? 0 : 1);

     }

-    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    erts_rwmtx_runlock(&environ_rwmtx);
     return res;

 }

 

@@ -171,12 +171,12 @@ win_build_environment(char* new_env)
 

 	tmp_new = (WCHAR *) new_env;

 	

-	erts_smp_rwmtx_rlock(&environ_rwmtx);

+	erts_rwmtx_rlock(&environ_rwmtx);
 	tmp = GetEnvironmentStringsW();

 	merged = merge_environment(tmp, tmp_new);

 

 	FreeEnvironmentStringsW(tmp);

-	erts_smp_rwmtx_runlock(&environ_rwmtx);

+	erts_rwmtx_runlock(&environ_rwmtx);
 	return (char *) merged;

     }

 }

diff --git a/erts/emulator/sys/win32/sys_interrupt.c b/erts/emulator/sys/win32/sys_interrupt.c
index 4632ab52b1..02aa50500f 100644
--- a/erts/emulator/sys/win32/sys_interrupt.c
+++ b/erts/emulator/sys/win32/sys_interrupt.c
@@ -35,11 +35,11 @@
 #  define WIN_SYS_INLINE __forceinline
 #endif
 
-erts_smp_atomic32_t erts_break_requested;
+erts_atomic32_t erts_break_requested;
 #define ERTS_SET_BREAK_REQUESTED \
-  erts_smp_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 1)
+  erts_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 1)
 #define ERTS_UNSET_BREAK_REQUESTED \
-  erts_smp_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 0)
+  erts_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 0)
 
 extern int nohup;
 HANDLE erts_sys_break_event = NULL;
@@ -51,14 +51,14 @@ void erts_do_break_handling(void)
      * therefore, make sure that all threads but this one are blocked before
      * proceeding!
      */
-    erts_smp_thr_progress_block();
+    erts_thr_progress_block();
     /* call the break handling function, reset the flag */
     do_break();
 
     ResetEvent(erts_sys_break_event);
     ERTS_UNSET_BREAK_REQUESTED;
 
-    erts_smp_thr_progress_unblock();
+    erts_thr_progress_unblock();
 }
 
 
diff --git a/erts/emulator/sys/win32/sys_time.c b/erts/emulator/sys/win32/sys_time.c
index 359010e9f1..25c2ad385c 100644
--- a/erts/emulator/sys/win32/sys_time.c
+++ b/erts/emulator/sys/win32/sys_time.c
@@ -95,7 +95,7 @@ struct sys_time_internal_state_read_mostly__ {
 };
 
 struct sys_time_internal_state_write_freq__ {
-    erts_smp_mtx_t mtime_mtx;
+    erts_mtx_t mtime_mtx;
     ULONGLONG wrap;
     ULONGLONG last_tick_count;
 };
@@ -294,7 +294,7 @@ sys_init_time(ErtsSysInitTimeResult *init_resp)
     module = GetModuleHandle(kernel_dll_name);
     if (!module) {
     get_tick_count:
-        erts_smp_mtx_init(&internal_state.w.f.mtime_mtx, "os_monotonic_time", NIL,
+        erts_mtx_init(&internal_state.w.f.mtime_mtx, "os_monotonic_time", NIL,
             ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 	internal_state.w.f.wrap = 0;
 	internal_state.w.f.last_tick_count = 0;