Unify host locks (#2049)

* Take and release host lock in event_execute

This avoids having to take and release the lock at finer granularity
while executing an event.

* Destroy and free Host shared memory

Author: sporksmith

src/lib/shim/shim_shmem.c

@@ -96,8 +96,9 @@ struct _ShimShmemThread {
 size_t shimshmemhost_size() { return sizeof(ShimShmemHost); }
 
 void shimshmemhost_init(ShimShmemHost* hostMem, Host* host, uint32_t unblockedSyscallLimit) {
-    // We use `memcpy` here to allow us to initialize the const members of
-    // `hostMem`.
+    assert(hostMem);
+    // We use `memcpy` instead of struct assignment here to allow us to
+    // initialize the const members of `hostMem`.
     memcpy(hostMem,
            &(ShimShmemHost){
                .host_id = host_getID(host),
@@ -111,6 +112,11 @@ void shimshmemhost_init(ShimShmemHost* hostMem, Host* host, uint32_t unblockedSy
            sizeof(ShimShmemHost));
 }
 
+void shimshmemhost_destroy(ShimShmemHost* hostMem) {
+    assert(hostMem);
+    pthread_mutex_destroy(&hostMem->mutex);
+}
+
 void shimshmem_incrementUnblockedSyscallCount(ShimShmemHostLock* host) {
     assert(host);
     ++host->unblocked_syscall_count;

src/lib/shim/shim_shmem.h

@@ -38,6 +38,7 @@ typedef struct _ShimHostProtectedSharedMem ShimShmemHostLock;
 
 size_t shimshmemhost_size();
 void shimshmemhost_init(ShimShmemHost* hostMem, Host* host, uint32_t unblockedSyscallLimit);
+void shimshmemhost_destroy(ShimShmemHost* hostMem);
 
 ShimShmemHostLock* shimshmemhost_lock(ShimShmemHost* host);
 

src/main/core/work/event.c

@@ -65,6 +65,7 @@ void event_execute(Event* event) {
     MAGIC_ASSERT(event);
 
     host_lock(event->dstHost);
+    host_lockShimShmemLock(event->dstHost);
     worker_setActiveHost(event->dstHost);
 
     /* check if we are allowed to execute or have to wait for cpu delays */
@@ -91,6 +92,7 @@ void event_execute(Event* event) {
     }
 
     worker_setActiveHost(NULL);
+    host_unlockShimShmemLock(event->dstHost);
     host_unlock(event->dstHost);
 }
 

src/main/host/host.c

@@ -308,6 +308,10 @@ void host_shutdown(Host* host) {
 
     if(host->defaultAddress) address_unref(host->defaultAddress);
     if(host->params.hostname) g_free(host->params.hostname);
+
+    utility_assert(host_getSharedMem(host));
+    shimshmemhost_destroy(host_getSharedMem(host));
+    shmemallocator_globalFree(&host->shimSharedMemBlock);
 }
 
 void host_ref(Host* host) {

src/main/host/process.c

@@ -648,8 +648,6 @@ void process_continue(Process* proc, Thread* thread) {
     worker_setActiveProcess(proc);
     worker_setActiveThread(thread);
 
-    host_lockShimShmemLock(proc->host);
-
 #ifdef USE_PERF_TIMERS
     /* time how long we execute the program */
     g_timer_start(proc->cpuDelayTimer);
@@ -678,8 +676,6 @@ void process_continue(Process* proc, Thread* thread) {
         _process_check_thread(proc, thread);
     }
 
-    host_unlockShimShmemLock(proc->host);
-
     worker_setActiveProcess(NULL);
     worker_setActiveThread(NULL);
 }

src/main/host/syscall_condition.c

@@ -336,9 +336,7 @@ static bool _syscallcondition_satisfied(SysCallCondition* cond, Host* host) {
         // Primary condition is satisfied.
         return true;
     }
-    ShimShmemHostLock* hostLock = shimshmemhost_lock(host_getSharedMem(host));
-    bool signalPending = thread_unblockedSignalPending(cond->thread, hostLock);
-    shimshmemhost_unlock(host_getSharedMem(host), &hostLock);
+    bool signalPending = thread_unblockedSignalPending(cond->thread, host_getShimShmemLock(host));
     if (signalPending) {
         return true;
     }