Classes | Namespaces | Macros | Enumerations | Functions | Variables 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

Go to the source code of this file.


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




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


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  absl::@339::DelayMode


 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 PerThreadSynchabsl::Dequeue (PerThreadSynch *head, PerThreadSynch *pw)
static PerThreadSynchabsl::DequeueAllWakeable (PerThreadSynch *head, PerThreadSynch *pw, PerThreadSynch **wake_tail)
static bool absl::Dereference (void *arg)
void absl::EnableMutexInvariantDebugging (bool enabled)
static PerThreadSynchabsl::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 PerThreadSynchabsl::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 PerThreadSynchabsl::Skip (PerThreadSynch *x)
static char * absl::StackString (void **pcs, int n, char *buf, int maxlen, bool symbolize)
static SynchLocksHeld * absl::Synch_GetAllLocks ()
static PerThreadSynchabsl::Synch_GetPerThread ()
static PerThreadSynchabsl::Synch_GetPerThreadAnnotated (Mutex *mu)
static bool absl::TryAcquireWithSpinning (std::atomic< intptr_t > *mu)
static void absl::UnrefSynchEvent (SynchEvent *e)


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

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

Definition at line 1867 of file

Enumeration Type Documentation

anonymous enum

Definition at line 220 of file

anonymous enum

Definition at line 240 of file

anonymous enum

Definition at line 1282 of file

enum absl::@339::DelayMode

Definition at line 144 of file

Function Documentation

ABSL_ATTRIBUTE_WEAK void AbslInternalMutexYield ( )

Definition at line 70 of file

SynchEvent *next GUARDED_BY ( synch_event_mu  )

Variable Documentation

void* arg

Definition at line 292 of file

DeadlockReportBuffers* b

Definition at line 1297 of file

char buf[6100]

Definition at line 1287 of file

void(* invariant) (void *arg)

Definition at line 291 of file

bool log

Definition at line 293 of file

uintptr_t masked_addr

Definition at line 286 of file

char name[1]

Definition at line 296 of file

int num_cpus

Definition at line 100 of file

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

Definition at line 103 of file

GraphId path[kMaxDeadlockPathLen]

Definition at line 1288 of file

int spinloop_iterations

Definition at line 101 of file

autogenerated on Wed Jun 19 2019 19:19:59