Keep track of which FuncNodes may write to a memory location
[c11tester.git] / action.cc
1 #include <stdio.h>
2 #define __STDC_FORMAT_MACROS
3 #include <inttypes.h>
4 #include <stdlib.h>
5
6 #include "model.h"
7 #include "action.h"
8 #include "clockvector.h"
9 #include "common.h"
10 #include "threads-model.h"
11 #include "wildcard.h"
12
13 #define ACTION_INITIAL_CLOCK 0
14
15 /** @brief A special value to represent a successful trylock */
16 #define VALUE_TRYSUCCESS 1
17
18 /** @brief A special value to represent a failed trylock */
19 #define VALUE_TRYFAILED 0
20
21 /**
22  * @brief Construct a new ModelAction
23  *
24  * @param type The type of action
25  * @param order The memory order of this action. A "don't care" for non-ATOMIC
26  * actions (e.g., THREAD_* or MODEL_* actions).
27  * @param loc The location that this action acts upon
28  * @param value (optional) A value associated with the action (e.g., the value
29  * read or written). Defaults to a given macro constant, for debugging purposes.
30  * @param thread (optional) The Thread in which this action occurred. If NULL
31  * (default), then a Thread is assigned according to the scheduler.
32  */
33 ModelAction::ModelAction(action_type_t type, memory_order order, void *loc,
34                                                                                                  uint64_t value, Thread *thread) :
35         location(loc),
36         position(NULL),
37         reads_from(NULL),
38         last_fence_release(NULL),
39         uninitaction(NULL),
40         cv(NULL),
41         rf_cv(NULL),
42         value(value),
43         type(type),
44         order(order),
45         original_order(order),
46         seq_number(ACTION_INITIAL_CLOCK)
47 {
48         /* References to NULL atomic variables can end up here */
49         ASSERT(loc || type == ATOMIC_FENCE || type == NOOP);
50
51         Thread *t = thread ? thread : thread_current();
52         this->tid = t!= NULL ? t->get_id() : -1;
53 }
54
55
56 /**
57  * @brief Construct a new ModelAction for sleep actions
58  *
59  * @param type The type of action: THREAD_SLEEP
60  * @param order The memory order of this action. A "don't care" for non-ATOMIC
61  * actions (e.g., THREAD_* or MODEL_* actions).
62  * @param loc The location that this action acts upon
63  * @param value The time duration a thread is scheduled to sleep.
64  * @param _time The this sleep action is constructed
65  */
66 ModelAction::ModelAction(action_type_t type, memory_order order, uint64_t value, uint64_t _time) :
67         location(NULL),
68         position(NULL),
69         time(_time),
70         last_fence_release(NULL),
71         uninitaction(NULL),
72         cv(NULL),
73         rf_cv(NULL),
74         value(value),
75         type(type),
76         order(order),
77         original_order(order),
78         seq_number(ACTION_INITIAL_CLOCK)
79 {
80         Thread *t = thread_current();
81         this->tid = t!= NULL ? t->get_id() : -1;
82 }
83
84 /**
85  * @brief Construct a new ModelAction
86  *
87  * @param type The type of action
88  * @param order The memory order of this action. A "don't care" for non-ATOMIC
89  * actions (e.g., THREAD_* or MODEL_* actions).
90  * @param loc The location that this action acts upon
91  * @param value (optional) A value associated with the action (e.g., the value
92  * read or written). Defaults to a given macro constant, for debugging purposes.
93  * @param size (optional) The Thread in which this action occurred. If NULL
94  * (default), then a Thread is assigned according to the scheduler.
95  */
96 ModelAction::ModelAction(action_type_t type, memory_order order, void *loc,
97                                                                                                  uint64_t value, int size) :
98         location(loc),
99         position(NULL),
100         reads_from(NULL),
101         last_fence_release(NULL),
102         uninitaction(NULL),
103         cv(NULL),
104         rf_cv(NULL),
105         value(value),
106         type(type),
107         order(order),
108         original_order(order),
109         seq_number(ACTION_INITIAL_CLOCK)
110 {
111         /* References to NULL atomic variables can end up here */
112         ASSERT(loc);
113         this->size = size;
114         Thread *t = thread_current();
115         this->tid = t->get_id();
116 }
117
118
119 /**
120  * @brief Construct a new ModelAction with source line number (requires llvm support)
121  *
122  * @param type The type of action
123  * @param order The memory order of this action. A "don't care" for non-ATOMIC
124  * actions (e.g., THREAD_* or MODEL_* actions).
125  * @param loc The location that this action acts upon
126  * @param value (optional) A value associated with the action (e.g., the value
127  * read or written). Defaults to a given macro constant, for debugging purposes.
128  * @param size (optional) The Thread in which this action occurred. If NULL
129  * (default), then a Thread is assigned according to the scheduler.
130  */
131 ModelAction::ModelAction(action_type_t type, const char * position, memory_order order, void *loc,
132                                                                                                  uint64_t value, int size) :
133         location(loc),
134         position(position),
135         reads_from(NULL),
136         last_fence_release(NULL),
137         uninitaction(NULL),
138         cv(NULL),
139         rf_cv(NULL),
140         value(value),
141         type(type),
142         order(order),
143         original_order(order),
144         seq_number(ACTION_INITIAL_CLOCK)
145 {
146         /* References to NULL atomic variables can end up here */
147         ASSERT(loc);
148         this->size = size;
149         Thread *t = thread_current();
150         this->tid = t->get_id();
151 }
152
153
154 /**
155  * @brief Construct a new ModelAction with source line number (requires llvm support)
156  *
157  * @param type The type of action
158  * @param position The source line number of this atomic operation
159  * @param order The memory order of this action. A "don't care" for non-ATOMIC
160  * actions (e.g., THREAD_* or MODEL_* actions).
161  * @param loc The location that this action acts upon
162  * @param value (optional) A value associated with the action (e.g., the value
163  * read or written). Defaults to a given macro constant, for debugging purposes.
164  * @param thread (optional) The Thread in which this action occurred. If NULL
165  * (default), then a Thread is assigned according to the scheduler.
166  */
167 ModelAction::ModelAction(action_type_t type, const char * position, memory_order order,
168                                                                                                  void *loc, uint64_t value, Thread *thread) :
169         location(loc),
170         position(position),
171         reads_from(NULL),
172         last_fence_release(NULL),
173         uninitaction(NULL),
174         cv(NULL),
175         rf_cv(NULL),
176         value(value),
177         type(type),
178         order(order),
179         original_order(order),
180         seq_number(ACTION_INITIAL_CLOCK)
181 {
182         /* References to NULL atomic variables can end up here */
183         ASSERT(loc || type == ATOMIC_FENCE);
184
185         Thread *t = thread ? thread : thread_current();
186         this->tid = t->get_id();
187 }
188
189
190 /** @brief ModelAction destructor */
191 ModelAction::~ModelAction()
192 {
193         /**
194          * We can't free the clock vector:
195          * Clock vectors are snapshotting state. When we delete model actions,
196          * they are at the end of the node list and have invalid old clock
197          * vectors which have already been rolled back to an unallocated state.
198          */
199
200         /*
201            if (cv)
202                 delete cv; */
203 }
204
205 int ModelAction::getSize() const {
206         return size;
207 }
208
209 void ModelAction::copy_from_new(ModelAction *newaction)
210 {
211         seq_number = newaction->seq_number;
212 }
213
214 void ModelAction::set_seq_number(modelclock_t num)
215 {
216         /* ATOMIC_UNINIT actions should never have non-zero clock */
217         ASSERT(!is_uninitialized());
218         ASSERT(seq_number == ACTION_INITIAL_CLOCK);
219         seq_number = num;
220 }
221
222 void ModelAction::reset_seq_number()
223 {
224         seq_number = 0;
225 }
226
227 bool ModelAction::is_thread_start() const
228 {
229         return type == THREAD_START;
230 }
231
232 bool ModelAction::is_thread_join() const
233 {
234         return type == THREAD_JOIN || type == PTHREAD_JOIN;
235 }
236
237 bool ModelAction::is_mutex_op() const
238 {
239         return type == ATOMIC_LOCK || type == ATOMIC_TRYLOCK || type == ATOMIC_UNLOCK || type == ATOMIC_WAIT || type == ATOMIC_TIMEDWAIT || type == ATOMIC_NOTIFY_ONE || type == ATOMIC_NOTIFY_ALL;
240 }
241
242 bool ModelAction::is_lock() const
243 {
244         return type == ATOMIC_LOCK;
245 }
246
247 bool ModelAction::is_sleep() const
248 {
249         return type == THREAD_SLEEP;
250 }
251
252 bool ModelAction::is_wait() const {
253         return type == ATOMIC_WAIT || type == ATOMIC_TIMEDWAIT;
254 }
255
256 bool ModelAction::is_notify() const {
257         return type == ATOMIC_NOTIFY_ONE || type == ATOMIC_NOTIFY_ALL;
258 }
259
260 bool ModelAction::is_notify_one() const {
261         return type == ATOMIC_NOTIFY_ONE;
262 }
263
264 bool ModelAction::is_unlock() const
265 {
266         return type == ATOMIC_UNLOCK;
267 }
268
269 bool ModelAction::is_trylock() const
270 {
271         return type == ATOMIC_TRYLOCK;
272 }
273
274 bool ModelAction::is_success_lock() const
275 {
276         return type == ATOMIC_LOCK || (type == ATOMIC_TRYLOCK && value == VALUE_TRYSUCCESS);
277 }
278
279 bool ModelAction::is_failed_trylock() const
280 {
281         return (type == ATOMIC_TRYLOCK && value == VALUE_TRYFAILED);
282 }
283
284 /** @return True if this operation is performed on a C/C++ atomic variable */
285 bool ModelAction::is_atomic_var() const
286 {
287         return is_read() || could_be_write();
288 }
289
290 bool ModelAction::is_uninitialized() const
291 {
292         return type == ATOMIC_UNINIT;
293 }
294
295 bool ModelAction::is_read() const
296 {
297         return type == ATOMIC_READ || type == ATOMIC_RMWR || type == ATOMIC_RMWRCAS || type == ATOMIC_RMW;
298 }
299
300 bool ModelAction::is_write() const
301 {
302         return type == ATOMIC_WRITE || type == ATOMIC_RMW || type == ATOMIC_INIT || type == ATOMIC_UNINIT || type == NONATOMIC_WRITE;
303 }
304
305 bool ModelAction::could_be_write() const
306 {
307         return is_write() || is_rmwr();
308 }
309
310 bool ModelAction::is_yield() const
311 {
312         return type == THREAD_YIELD;
313 }
314
315 bool ModelAction::is_rmwr() const
316 {
317         return type == ATOMIC_RMWR || type == ATOMIC_RMWRCAS;
318 }
319
320 bool ModelAction::is_rmwrcas() const
321 {
322         return type == ATOMIC_RMWRCAS;
323 }
324
325 bool ModelAction::is_rmw() const
326 {
327         return type == ATOMIC_RMW;
328 }
329
330 bool ModelAction::is_rmwc() const
331 {
332         return type == ATOMIC_RMWC;
333 }
334
335 bool ModelAction::is_fence() const
336 {
337         return type == ATOMIC_FENCE;
338 }
339
340 bool ModelAction::is_initialization() const
341 {
342         return type == ATOMIC_INIT;
343 }
344
345 bool ModelAction::is_annotation() const
346 {
347         return type == ATOMIC_ANNOTATION;
348 }
349
350 bool ModelAction::is_relaxed() const
351 {
352         return order == std::memory_order_relaxed;
353 }
354
355 bool ModelAction::is_acquire() const
356 {
357         switch (order) {
358         case std::memory_order_acquire:
359         case std::memory_order_acq_rel:
360         case std::memory_order_seq_cst:
361                 return true;
362         default:
363                 return false;
364         }
365 }
366
367 bool ModelAction::is_release() const
368 {
369         switch (order) {
370         case std::memory_order_release:
371         case std::memory_order_acq_rel:
372         case std::memory_order_seq_cst:
373                 return true;
374         default:
375                 return false;
376         }
377 }
378
379 bool ModelAction::is_seqcst() const
380 {
381         return order == std::memory_order_seq_cst;
382 }
383
384 bool ModelAction::same_var(const ModelAction *act) const
385 {
386         if (act->is_wait() || is_wait()) {
387                 if (act->is_wait() && is_wait()) {
388                         if (((void *)value) == ((void *)act->value))
389                                 return true;
390                 } else if (is_wait()) {
391                         if (((void *)value) == act->location)
392                                 return true;
393                 } else if (act->is_wait()) {
394                         if (location == ((void *)act->value))
395                                 return true;
396                 }
397         }
398
399         return location == act->location;
400 }
401
402 bool ModelAction::same_thread(const ModelAction *act) const
403 {
404         return tid == act->tid;
405 }
406
407 void ModelAction::copy_typeandorder(ModelAction * act)
408 {
409         this->type = act->type;
410         this->order = act->order;
411 }
412
413 /**
414  * Get the Thread which is the operand of this action. This is only valid for
415  * THREAD_* operations (currently only for THREAD_CREATE and THREAD_JOIN). Note
416  * that this provides a central place for determining the conventions of Thread
417  * storage in ModelAction, where we generally aren't very type-safe (e.g., we
418  * store object references in a (void *) address.
419  *
420  * For THREAD_CREATE, this yields the Thread which is created.
421  * For THREAD_JOIN, this yields the Thread we are joining with.
422  *
423  * @return The Thread which this action acts on, if exists; otherwise NULL
424  */
425 Thread * ModelAction::get_thread_operand() const
426 {
427         if (type == THREAD_CREATE) {
428                 /* thread_operand is set in execution.cc */
429                 return thread_operand;
430         } else if (type == PTHREAD_CREATE) {
431                 return thread_operand;
432         } else if (type == THREAD_JOIN) {
433                 /* THREAD_JOIN uses (Thread *) for location */
434                 return (Thread *)get_location();
435         } else if (type == PTHREAD_JOIN) {
436                 // return NULL;
437                 // thread_operand is stored in execution::pthread_map;
438                 return (Thread *)get_location();
439         } else
440                 return NULL;
441 }
442
443 /**
444  * @brief Convert the read portion of an RMW
445  *
446  * Changes an existing read part of an RMW action into either:
447  *  -# a full RMW action in case of the completed write or
448  *  -# a READ action in case a failed action.
449  *
450  * @todo  If the memory_order changes, we may potentially need to update our
451  * clock vector.
452  *
453  * @param act The second half of the RMW (either RMWC or RMW)
454  */
455 void ModelAction::process_rmw(ModelAction *act)
456 {
457         this->order = act->order;
458         if (act->is_rmwc())
459                 this->type = ATOMIC_READ;
460         else if (act->is_rmw()) {
461                 this->type = ATOMIC_RMW;
462                 this->value = act->value;
463         }
464 }
465
466 /**
467  * @brief Check if this action should be backtracked with another, due to
468  * potential synchronization
469  *
470  * The is_synchronizing method should only explore interleavings if:
471  *  -# the operations are seq_cst and don't commute or
472  *  -# the reordering may establish or break a synchronization relation.
473  *
474  * Other memory operations will be dealt with by using the reads_from relation.
475  *
476  * @param act The action to consider exploring a reordering
477  * @return True, if we have to explore a reordering; otherwise false
478  */
479 bool ModelAction::could_synchronize_with(const ModelAction *act) const
480 {
481         // Same thread can't be reordered
482         if (same_thread(act))
483                 return false;
484
485         // Different locations commute
486         if (!same_var(act) && !is_fence() && !act->is_fence())
487                 return false;
488
489         // Explore interleavings of seqcst writes/fences to guarantee total
490         // order of seq_cst operations that don't commute
491         if ((could_be_write() || act->could_be_write() || is_fence() || act->is_fence()) && is_seqcst() && act->is_seqcst())
492                 return true;
493
494         // Explore synchronizing read/write pairs
495         if (is_acquire() && act->is_release() && is_read() && act->could_be_write())
496                 return true;
497
498         // lock just released...we can grab lock
499         if ((is_lock() || is_trylock()) && (act->is_unlock() || act->is_wait()))
500                 return true;
501
502         // lock just acquired...we can fail to grab lock
503         if (is_trylock() && act->is_success_lock())
504                 return true;
505
506         // other thread stalling on lock...we can release lock
507         if (is_unlock() && (act->is_trylock() || act->is_lock()))
508                 return true;
509
510         if (is_trylock() && (act->is_unlock() || act->is_wait()))
511                 return true;
512
513         if (is_notify() && act->is_wait())
514                 return true;
515
516         if (is_wait() && act->is_notify())
517                 return true;
518
519         // Otherwise handle by reads_from relation
520         return false;
521 }
522
523 bool ModelAction::is_conflicting_lock(const ModelAction *act) const
524 {
525         // Must be different threads to reorder
526         if (same_thread(act))
527                 return false;
528
529         // Try to reorder a lock past a successful lock
530         if (act->is_success_lock())
531                 return true;
532
533         // Try to push a successful trylock past an unlock
534         if (act->is_unlock() && is_trylock() && value == VALUE_TRYSUCCESS)
535                 return true;
536
537         // Try to push a successful trylock past a wait
538         if (act->is_wait() && is_trylock() && value == VALUE_TRYSUCCESS)
539                 return true;
540
541         return false;
542 }
543
544 /**
545  * Create a new clock vector for this action. Note that this function allows a
546  * user to clobber (and leak) a ModelAction's existing clock vector. A user
547  * should ensure that the vector has already either been rolled back
548  * (effectively "freed") or freed.
549  *
550  * @param parent A ModelAction from which to inherit a ClockVector
551  */
552 void ModelAction::create_cv(const ModelAction *parent)
553 {
554         if (parent)
555                 cv = new ClockVector(parent->cv, this);
556         else
557                 cv = new ClockVector(NULL, this);
558 }
559
560 void ModelAction::set_try_lock(bool obtainedlock)
561 {
562         value = obtainedlock ? VALUE_TRYSUCCESS : VALUE_TRYFAILED;
563 }
564
565 /**
566  * @brief Get the value read by this load
567  *
568  * We differentiate this function from ModelAction::get_write_value and
569  * ModelAction::get_value for the purpose of RMW's, which may have both a
570  * 'read' and a 'write' value.
571  *
572  * Note: 'this' must be a load.
573  *
574  * @return The value read by this load
575  */
576 uint64_t ModelAction::get_reads_from_value() const
577 {
578         ASSERT(is_read());
579         if (reads_from)
580                 return reads_from->get_write_value();
581
582         return VALUE_NONE;      // Only for new actions with no reads-from
583 }
584
585 /**
586  * @brief Get the value written by this store
587  *
588  * We differentiate this function from ModelAction::get_reads_from_value and
589  * ModelAction::get_value for the purpose of RMW's, which may have both a
590  * 'read' and a 'write' value.
591  *
592  * Note: 'this' must be a store.
593  *
594  * @return The value written by this store
595  */
596 uint64_t ModelAction::get_write_value() const
597 {
598         ASSERT(is_write());
599         return value;
600 }
601
602 /**
603  * @brief Get the value returned by this action
604  *
605  * For atomic reads (including RMW), an operation returns the value it read.
606  * For atomic writes, an operation returns the value it wrote. For other
607  * operations, the return value varies (sometimes is a "don't care"), but the
608  * value is simply stored in the "value" field.
609  *
610  * @return This action's return value
611  */
612 uint64_t ModelAction::get_return_value() const
613 {
614         if (is_read())
615                 return get_reads_from_value();
616         else if (is_write())
617                 return get_write_value();
618         else
619                 return value;
620 }
621
622 /**
623  * Update the model action's read_from action
624  * @param act The action to read from; should be a write
625  */
626 void ModelAction::set_read_from(ModelAction *act)
627 {
628         ASSERT(act);
629
630         reads_from = act;
631         if (act->is_uninitialized()) {  // WL
632                 uint64_t val = *((uint64_t *) location);
633                 ModelAction * act_uninitialized = (ModelAction *)act;
634                 act_uninitialized->set_value(val);
635                 reads_from = act_uninitialized;
636
637 // disabled by WL, because LLVM IR is unable to detect atomic init
638 /*              model->assert_bug("May read from uninitialized atomic:\n"
639                                 "    action %d, thread %d, location %p (%s, %s)",
640                                 seq_number, id_to_int(tid), location,
641                                 get_type_str(), get_mo_str());
642  */
643         }
644 }
645
646 /**
647  * Synchronize the current thread with the thread corresponding to the
648  * ModelAction parameter.
649  * @param act The ModelAction to synchronize with
650  * @return True if this is a valid synchronization; false otherwise
651  */
652 bool ModelAction::synchronize_with(const ModelAction *act)
653 {
654         if (*this < *act)
655                 return false;
656         cv->merge(act->cv);
657         return true;
658 }
659
660 bool ModelAction::has_synchronized_with(const ModelAction *act) const
661 {
662         return cv->synchronized_since(act);
663 }
664
665 /**
666  * Check whether 'this' happens before act, according to the memory-model's
667  * happens before relation. This is checked via the ClockVector constructs.
668  * @return true if this action's thread has synchronized with act's thread
669  * since the execution of act, false otherwise.
670  */
671 bool ModelAction::happens_before(const ModelAction *act) const
672 {
673         return act->cv->synchronized_since(this);
674 }
675
676 const char * ModelAction::get_type_str() const
677 {
678         switch (this->type) {
679         case THREAD_CREATE: return "thread create";
680         case THREAD_START: return "thread start";
681         case THREAD_YIELD: return "thread yield";
682         case THREAD_JOIN: return "thread join";
683         case THREAD_FINISH: return "thread finish";
684         case THREAD_SLEEP: return "thread sleep";
685         case THREADONLY_FINISH: return "pthread_exit finish";
686
687         case PTHREAD_CREATE: return "pthread create";
688         case PTHREAD_JOIN: return "pthread join";
689
690         case ATOMIC_UNINIT: return "uninitialized";
691         case NONATOMIC_WRITE: return "nonatomic write";
692         case ATOMIC_READ: return "atomic read";
693         case ATOMIC_WRITE: return "atomic write";
694         case ATOMIC_RMW: return "atomic rmw";
695         case ATOMIC_FENCE: return "fence";
696         case ATOMIC_RMWR: return "atomic rmwr";
697         case ATOMIC_RMWRCAS: return "atomic rmwrcas";
698         case ATOMIC_RMWC: return "atomic rmwc";
699         case ATOMIC_INIT: return "init atomic";
700         case ATOMIC_LOCK: return "lock";
701         case ATOMIC_UNLOCK: return "unlock";
702         case ATOMIC_TRYLOCK: return "trylock";
703         case ATOMIC_WAIT: return "wait";
704         case ATOMIC_TIMEDWAIT: return "timed wait";
705         case ATOMIC_NOTIFY_ONE: return "notify one";
706         case ATOMIC_NOTIFY_ALL: return "notify all";
707         case ATOMIC_ANNOTATION: return "annotation";
708         default: return "unknown type";
709         };
710 }
711
712 const char * ModelAction::get_mo_str() const
713 {
714         switch (this->order) {
715         case std::memory_order_relaxed: return "relaxed";
716         case std::memory_order_acquire: return "acquire";
717         case std::memory_order_release: return "release";
718         case std::memory_order_acq_rel: return "acq_rel";
719         case std::memory_order_seq_cst: return "seq_cst";
720         default: return "unknown";
721         }
722 }
723
724 /** @brief Print nicely-formatted info about this ModelAction */
725 void ModelAction::print() const
726 {
727         const char *type_str = get_type_str(), *mo_str = get_mo_str();
728
729         model_print("%-4d %-2d   %-14s  %7s  %14p   %-#18" PRIx64,
730                                                         seq_number, id_to_int(tid), type_str, mo_str, location, get_return_value());
731         if (is_read()) {
732                 if (reads_from)
733                         model_print("  %-3d", reads_from->get_seq_number());
734                 else
735                         model_print("  ?  ");
736         }
737         if (cv) {
738                 if (is_read())
739                         model_print(" ");
740                 else
741                         model_print("      ");
742                 cv->print();
743         } else
744                 model_print("\n");
745 }
746
747 /** @brief Get a (likely) unique hash for this ModelAction */
748 unsigned int ModelAction::hash() const
749 {
750         unsigned int hash = (unsigned int)this->type;
751         hash ^= ((unsigned int)this->order) << 3;
752         hash ^= seq_number << 5;
753         hash ^= id_to_int(tid) << 6;
754
755         if (is_read()) {
756                 if (reads_from)
757                         hash ^= reads_from->get_seq_number();
758                 hash ^= get_reads_from_value();
759         }
760         return hash;
761 }
762
763 /**
764  * Only valid for LOCK, TRY_LOCK, UNLOCK, and WAIT operations.
765  * @return The mutex operated on by this action, if any; otherwise NULL
766  */
767 cdsc::mutex * ModelAction::get_mutex() const
768 {
769         if (is_trylock() || is_lock() || is_unlock())
770                 return (cdsc::mutex *)get_location();
771         else if (is_wait())
772                 return (cdsc::mutex *)get_value();
773         else
774                 return NULL;
775 }