Classes | Namespaces | Defines | 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


namespace  absl


#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  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)
 absl::static_assert (PerThreadSynch::kAlignment > kMuLow,"PerThreadSynch::kAlignment must be greater than kMuLow")
 absl::static_assert (PerThreadSynch::kAlignment > kCvLow,"PerThreadSynch::kAlignment must be greater than kCvLow")
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
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]
absl::synch_event_mu (absl::base_internal::kLinkerInitialized)
static const intptr_t absl::zap_desig_waker []

Define 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)

Definition at line 1867 of file

Function Documentation

Definition at line 70 of file

SynchEvent *next GUARDED_BY ( synch_event_mu  )

Variable Documentation

void* arg

Definition at line 313 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 312 of file

bool log

Definition at line 314 of file

uintptr_t masked_addr

Definition at line 307 of file

char name[1]

Definition at line 317 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

Definition at line 101 of file

autogenerated on Wed Jun 19 2019 19:42:16