Classes | Namespaces | Macros | Enumerations | Functions | Variables
mutex.cc File Reference
#include "absl/synchronization/mutex.h"
#include <fcntl.h>
#include <pthread.h>
#include <sched.h>
#include <sys/time.h>
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <algorithm>
#include <atomic>
#include <cinttypes>
#include <thread>
#include "absl/base/attributes.h"
#include "absl/base/config.h"
#include "absl/base/dynamic_annotations.h"
#include "absl/base/internal/atomic_hook.h"
#include "absl/base/internal/cycleclock.h"
#include "absl/base/internal/hide_ptr.h"
#include "absl/base/internal/low_level_alloc.h"
#include "absl/base/internal/raw_logging.h"
#include "absl/base/internal/spinlock.h"
#include "absl/base/internal/sysinfo.h"
#include "absl/base/internal/thread_identity.h"
#include "absl/base/port.h"
#include "absl/debugging/stacktrace.h"
#include "absl/debugging/symbolize.h"
#include "absl/synchronization/internal/graphcycles.h"
#include "absl/synchronization/internal/per_thread_sem.h"
Include dependency graph for mutex.cc:

Go to the source code of this file.

Classes

struct  absl::MuHowS
 
struct  absl::SynchEvent
 
struct  absl::SynchLocksHeld
 
struct  absl::SynchWaitParams
 

Namespaces

 absl
 

Macros

#define __tsan_read1(addr)
 
#define RAW_CHECK_FMT(cond, ...)
 

Enumerations

enum  {
  absl::kGdbMuSpin = kMuSpin, absl::kGdbMuEvent = kMuEvent, absl::kGdbMuWait = kMuWait, absl::kGdbMuWriter = kMuWriter,
  absl::kGdbMuDesig = kMuDesig, absl::kGdbMuWrWait = kMuWrWait, absl::kGdbMuReader = kMuReader, absl::kGdbMuLow = kMuLow
}
 
enum  { absl::kGdbCvSpin = kCvSpin, absl::kGdbCvEvent = kCvEvent, absl::kGdbCvLow = kCvLow }
 
enum  
 
enum  
 
enum  
 
enum  absl::@339::DelayMode
 

Functions

 absl::ABSL_XRAY_LOG_ARGS (1) void Mutex
 
ABSL_ATTRIBUTE_WEAK void AbslInternalMutexYield ()
 
static void absl::AtomicClearBits (std::atomic< intptr_t > *pv, intptr_t bits, intptr_t wait_until_clear)
 
static void absl::AtomicSetBits (std::atomic< intptr_t > *pv, intptr_t bits, intptr_t wait_until_clear)
 
static void absl::CheckForMutexCorruption (intptr_t v, const char *label)
 
static void absl::CondVarEnqueue (SynchWaitParams *waitp)
 
static char * absl::CurrentStackString (char *buf, int maxlen, bool symbolize)
 
static absl::Time absl::DeadlineFromTimeout (absl::Duration timeout)
 
static GraphId absl::DeadlockCheck (Mutex *mu)
 
static GraphId absl::DebugOnlyDeadlockCheck (Mutex *mu)
 
static bool absl::DebugOnlyIsExiting ()
 
static void absl::DebugOnlyLockEnter (Mutex *mu)
 
static void absl::DebugOnlyLockEnter (Mutex *mu, GraphId id)
 
static void absl::DebugOnlyLockLeave (Mutex *mu)
 
static int absl::Delay (int32_t c, DelayMode mode)
 
static void absl::DeleteSynchEvent (SynchEvent *e)
 
static PerThreadSynch * absl::Dequeue (PerThreadSynch *head, PerThreadSynch *pw)
 
static PerThreadSynch * absl::DequeueAllWakeable (PerThreadSynch *head, PerThreadSynch *pw, PerThreadSynch **wake_tail)
 
static bool absl::Dereference (void *arg)
 
void absl::EnableMutexInvariantDebugging (bool enabled)
 
static PerThreadSynch * absl::Enqueue (PerThreadSynch *head, SynchWaitParams *waitp, intptr_t mu, int flags)
 
static SynchEvent * absl::EnsureSynchEvent (std::atomic< intptr_t > *addr, const char *name, intptr_t bits, intptr_t lockbit)
 
static bool absl::EvalConditionAnnotated (const Condition *cond, Mutex *mu, bool locking, bool trylock, bool read_lock)
 
static bool absl::EvalConditionIgnored (Mutex *mu, const Condition *cond)
 
static bool absl::ExactlyOneReader (intptr_t v)
 
static void absl::FixSkip (PerThreadSynch *ancestor, PerThreadSynch *to_be_removed)
 
static void absl::ForgetSynchEvent (std::atomic< intptr_t > *addr, intptr_t bits, intptr_t lockbit)
 
static GraphId absl::GetGraphId (Mutex *mu) LOCKS_EXCLUDED(deadlock_graph_mu)
 
static GraphId absl::GetGraphIdLocked (Mutex *mu) EXCLUSIVE_LOCKS_REQUIRED(deadlock_graph_mu)
 
static PerThreadSynch * absl::GetPerThreadSynch (intptr_t v)
 
static SynchEvent * absl::GetSynchEvent (const void *addr)
 
static GraphCycles *deadlock_graph absl::GUARDED_BY (deadlock_graph_mu) PT_GUARDED_BY(deadlock_graph_mu)
 
static struct absl::SynchEvent absl::GUARDED_BY (synch_event_mu)
 
int refcount GUARDED_BY (synch_event_mu)
 
static void absl::LockEnter (Mutex *mu, GraphId id, SynchLocksHeld *held_locks)
 
static void absl::LockLeave (Mutex *mu, GraphId id, SynchLocksHeld *held_locks)
 
static SynchLocksHeld * absl::LocksHeldAlloc ()
 
static bool absl::MuSameCondition (PerThreadSynch *x, PerThreadSynch *y)
 
static void absl::PostSynchEvent (void *obj, int ev)
 
void absl::RegisterCondVarTracer (void(*fn)(const char *msg, const void *cv))
 
void absl::RegisterMutexProfiler (void(*fn)(int64_t wait_timestamp))
 
void absl::RegisterMutexTracer (void(*fn)(const char *msg, const void *obj, int64_t wait_cycles))
 
void absl::RegisterSymbolizer (bool(*fn)(const void *pc, char *out, int out_size))
 
void absl::SetMutexDeadlockDetectionMode (OnDeadlockCycle mode)
 
static PerThreadSynch * absl::Skip (PerThreadSynch *x)
 
static char * absl::StackString (void **pcs, int n, char *buf, int maxlen, bool symbolize)
 
static SynchLocksHeld * absl::Synch_GetAllLocks ()
 
static PerThreadSynch * absl::Synch_GetPerThread ()
 
static PerThreadSynch * absl::Synch_GetPerThreadAnnotated (Mutex *mu)
 
static bool absl::TryAcquireWithSpinning (std::atomic< intptr_t > *mu)
 
static void absl::UnrefSynchEvent (SynchEvent *e)
 

Variables

void * arg
 
static absl::base_internal::SpinLock absl::deadlock_graph_mu (absl::base_internal::kLinkerInitialized)
 
struct {
   int   absl::flags
 
   const char *   absl::msg
 
} absl::event_properties []
 
struct absl::SynchWaitParams absl::GUARDED_BY [kNSynchEvent]
 
static const intptr_t absl::ignore_waiting_writers []
 
void(* invariant )(void *arg)
 
static const intptr_t absl::kCvEvent = 0x0002L
 
static const intptr_t absl::kCvLow = 0x0003L
 
static const intptr_t absl::kCvSpin = 0x0001L
 
static constexpr bool absl::kDebugMode = true
 
static const Mutex::MuHow absl::kExclusive = &kExclusiveS
 
static const MuHowS absl::kExclusiveS
 
static const intptr_t absl::kMuDesig = 0x0002L
 
static const intptr_t absl::kMuEvent = 0x0010L
 
static const int absl::kMuHasBlocked = 0x01
 
static const intptr_t absl::kMuHigh = ~kMuLow
 
static const int absl::kMuIsCond = 0x02
 
static const intptr_t absl::kMuLow = 0x00ffL
 
static const intptr_t absl::kMuOne = 0x0100
 
static const intptr_t absl::kMuReader = 0x0001L
 
static const intptr_t absl::kMuSpin = 0x0040L
 
static const intptr_t absl::kMuWait = 0x0004L
 
static const intptr_t absl::kMuWriter = 0x0008L
 
static const intptr_t absl::kMuWrWait = 0x0020L
 
static const uint32_t absl::kNSynchEvent = 1031
 
static PerThreadSynch *const absl::kPerThreadSynchNull
 
static const Mutex::MuHow absl::kShared = &kSharedS
 
static const MuHowS absl::kSharedS
 
bool log
 
uintptr_t masked_addr
 
char name [1]
 
static absl::base_internal::SpinLock absl::synch_event_mu (absl::base_internal::kLinkerInitialized)
 
static const intptr_t absl::zap_desig_waker []
 

Macro Definition Documentation

#define __tsan_read1 (   addr)

Definition at line 2675 of file mutex.cc.

#define RAW_CHECK_FMT (   cond,
  ... 
)
Value:
do { \
if (ABSL_PREDICT_FALSE(!(cond))) { \
ABSL_RAW_LOG(FATAL, "Check " #cond " failed: " __VA_ARGS__); \
} \
} while (0)
ABSL_RAW_LOG
#define ABSL_RAW_LOG(severity,...)
Definition: raw_logging.h:42
ABSL_PREDICT_FALSE
#define ABSL_PREDICT_FALSE(x)
Definition: optimization.h:177

Definition at line 1867 of file mutex.cc.

Enumeration Type Documentation

anonymous enum

Definition at line 220 of file mutex.cc.

anonymous enum

Definition at line 240 of file mutex.cc.

anonymous enum

Definition at line 1282 of file mutex.cc.

enum absl::@339::DelayMode

Definition at line 144 of file mutex.cc.

Function Documentation

ABSL_ATTRIBUTE_WEAK void AbslInternalMutexYield ( )

Definition at line 70 of file mutex.cc.

SynchEvent *next GUARDED_BY ( synch_event_mu  )

Variable Documentation

void* arg

Definition at line 292 of file mutex.cc.

DeadlockReportBuffers* b

Definition at line 1297 of file mutex.cc.

char buf[6100]

Definition at line 1287 of file mutex.cc.

void(* invariant) (void *arg)

Definition at line 291 of file mutex.cc.

bool log

Definition at line 293 of file mutex.cc.

uintptr_t masked_addr

Definition at line 286 of file mutex.cc.

char name[1]

Definition at line 296 of file mutex.cc.

int num_cpus

Definition at line 100 of file mutex.cc.

char padding[ABSL_CACHELINE_SIZE-2 *sizeof(int)]

Definition at line 103 of file mutex.cc.

GraphId path[kMaxDeadlockPathLen]

Definition at line 1288 of file mutex.cc.

int spinloop_iterations

Definition at line 101 of file mutex.cc.


abseil_cpp
Author(s):
autogenerated on Wed Jun 19 2019 19:19:59