Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
6b94db74bc2ceb45d8a2ccea291f26044d8dbac1
[simgrid.git] / src / kernel / activity / MutexImpl.cpp
1 /* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "src/kernel/activity/MutexImpl.hpp"
7 #include "src/kernel/activity/SynchroRaw.hpp"
8
9 #include "src/simix/smx_private.hpp"
10
11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_mutex, simix_synchro, "Mutex kernel-space implementation");
12
13 namespace simgrid {
14 namespace kernel {
15 namespace activity {
16
17 MutexImpl::MutexImpl() : mutex_(this)
18 {
19   XBT_IN("(%p)", this);
20   XBT_OUT();
21 }
22
23 MutexImpl::~MutexImpl()
24 {
25   XBT_IN("(%p)", this);
26   XBT_OUT();
27 }
28
29 void MutexImpl::lock(smx_actor_t issuer)
30 {
31   XBT_IN("(%p; %p)", this, issuer);
32   /* FIXME: check where to validate the arguments */
33   smx_activity_t synchro = nullptr;
34
35   if (this->locked) {
36     /* FIXME: check if the host is active ? */
37     /* Somebody using the mutex, use a synchronization to get host failures */
38     synchro = SIMIX_synchro_wait(issuer->host, -1);
39     synchro->simcalls.push_back(&issuer->simcall);
40     issuer->waiting_synchro = synchro;
41     this->sleeping.push_back(*issuer);
42   } else {
43     /* mutex free */
44     this->locked = true;
45     this->owner  = issuer;
46     SIMIX_simcall_answer(&issuer->simcall);
47   }
48   XBT_OUT();
49 }
50
51 /** Tries to lock the mutex for a process
52  *
53  * \param  issuer  the process that tries to acquire the mutex
54  * \return whether we managed to lock the mutex
55  */
56 bool MutexImpl::try_lock(smx_actor_t issuer)
57 {
58   XBT_IN("(%p, %p)", this, issuer);
59   if (this->locked) {
60     XBT_OUT();
61     return false;
62   }
63
64   this->locked = true;
65   this->owner  = issuer;
66   XBT_OUT();
67   return true;
68 }
69
70 /** Unlock a mutex for a process
71  *
72  * Unlocks the mutex and gives it to a process waiting for it.
73  * If the unlocker is not the owner of the mutex nothing happens.
74  * If there are no process waiting, it sets the mutex as free.
75  */
76 void MutexImpl::unlock(smx_actor_t issuer)
77 {
78   XBT_IN("(%p, %p)", this, issuer);
79   if (not this->locked)
80     THROWF(mismatch_error, 0, "Cannot release that mutex: it was not locked.");
81
82   /* If the mutex is not owned by the issuer, that's not good */
83   if (issuer != this->owner)
84     THROWF(mismatch_error, 0, "Cannot release that mutex: it was locked by %s (pid:%lu), not by you.",
85            this->owner->getCname(), this->owner->pid);
86
87   if (not this->sleeping.empty()) {
88     /*process to wake up */
89     smx_actor_t p = &this->sleeping.front();
90     this->sleeping.pop_front();
91     p->waiting_synchro = nullptr;
92     this->owner        = p;
93     SIMIX_simcall_answer(&p->simcall);
94   } else {
95     /* nobody to wake up */
96     this->locked = false;
97     this->owner  = nullptr;
98   }
99   XBT_OUT();
100 }
101 }
102 }
103 }
104
105 /** Increase the refcount for this mutex */
106 smx_mutex_t SIMIX_mutex_ref(smx_mutex_t mutex)
107 {
108   if (mutex != nullptr)
109     intrusive_ptr_add_ref(mutex);
110   return mutex;
111 }
112
113 /** Decrease the refcount for this mutex */
114 void SIMIX_mutex_unref(smx_mutex_t mutex)
115 {
116   if (mutex != nullptr)
117     intrusive_ptr_release(mutex);
118 }
119
120 // Simcall handlers:
121
122 void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex)
123 {
124   mutex->lock(simcall->issuer);
125 }
126
127 int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex)
128 {
129   return mutex->try_lock(simcall->issuer);
130 }
131
132 void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex)
133 {
134   mutex->unlock(simcall->issuer);
135 }