0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-10-31 19:08:59 +01:00
construct/ircd/db_port.cc

371 lines
5.7 KiB
C++

// Matrix Construct
//
// Copyright (C) Matrix Construct Developers, Authors & Contributors
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice is present in all copies. The
// full license for this software is available in the LICENSE file.
#include "db.h"
//
// Mutex
//
static_assert
(
sizeof(rocksdb::port::Mutex) <= sizeof(pthread_mutex_t) + 1,
"link-time punning of our structure won't work if the structure is larger "
"than the one rocksdb has assumed space for."
);
rocksdb::port::Mutex::Mutex()
noexcept
{
memset(this, 0x0, sizeof(pthread_mutex_t));
if constexpr(RB_DEBUG_DB_PORT > 1)
{
if(unlikely(!ctx::current))
return;
log::debug
{
db::log, "mutex %lu %p CTOR",
ctx::id(),
this
};
}
}
rocksdb::port::Mutex::Mutex(bool adaptive)
noexcept
:Mutex{}
{
}
rocksdb::port::Mutex::~Mutex()
noexcept
{
if constexpr(RB_DEBUG_DB_PORT > 1)
{
if(unlikely(!ctx::current))
return;
log::debug
{
db::log, "mutex %lu %p DTOR",
ctx::id(),
this
};
}
}
void
rocksdb::port::Mutex::Lock()
noexcept
{
if(unlikely(!ctx::current))
return;
if constexpr(RB_DEBUG_DB_PORT)
log::debug
{
db::log, "mutex %lu %p LOCK",
ctx::id(),
this
};
assert_main_thread();
const ctx::uninterruptible::nothrow ui;
mu.lock();
}
void
rocksdb::port::Mutex::Unlock()
noexcept
{
if(unlikely(!ctx::current))
return;
if constexpr(RB_DEBUG_DB_PORT)
log::debug
{
db::log, "mutex %lu %p UNLOCK",
ctx::id(),
this
};
assert_main_thread();
assert(mu.locked());
const ctx::uninterruptible::nothrow ui;
mu.unlock();
}
void
rocksdb::port::Mutex::AssertHeld()
noexcept
{
assert(!ctx::current || mu.locked());
}
//
// RWMutex
//
static_assert
(
sizeof(rocksdb::port::RWMutex) <= sizeof(pthread_rwlock_t),
"link-time punning of our structure won't work if the structure is larger "
"than the one rocksdb has assumed space for."
);
rocksdb::port::RWMutex::RWMutex()
noexcept
{
memset(this, 0x0, sizeof(pthread_rwlock_t));
if constexpr(RB_DEBUG_DB_PORT > 1)
{
if(unlikely(!ctx::current))
return;
log::debug
{
db::log, "shared_mutex %lu %p CTOR",
ctx::id(),
this
};
}
}
rocksdb::port::RWMutex::~RWMutex()
noexcept
{
if constexpr(RB_DEBUG_DB_PORT > 1)
{
if(unlikely(!ctx::current))
return;
log::debug
{
db::log, "shared_mutex %lu %p DTOR",
ctx::id(),
this
};
}
}
void
rocksdb::port::RWMutex::ReadLock()
noexcept
{
if(unlikely(!ctx::current))
return;
if constexpr(RB_DEBUG_DB_PORT)
log::debug
{
db::log, "shared_mutex %lu %p LOCK SHARED",
ctx::id(),
this
};
assert_main_thread();
const ctx::uninterruptible::nothrow ui;
mu.lock_shared();
}
void
rocksdb::port::RWMutex::WriteLock()
noexcept
{
if(unlikely(!ctx::current))
return;
if constexpr(RB_DEBUG_DB_PORT)
log::debug
{
db::log, "shared_mutex %lu %p LOCK",
ctx::id(),
this
};
assert_main_thread();
const ctx::uninterruptible::nothrow ui;
mu.lock();
}
void
rocksdb::port::RWMutex::ReadUnlock()
noexcept
{
if(unlikely(!ctx::current))
return;
if constexpr(RB_DEBUG_DB_PORT)
log::debug
{
db::log, "shared_mutex %lu %p UNLOCK SHARED",
ctx::id(),
this
};
assert_main_thread();
const ctx::uninterruptible::nothrow ui;
mu.unlock_shared();
}
void
rocksdb::port::RWMutex::WriteUnlock()
noexcept
{
if(unlikely(!ctx::current))
return;
if constexpr(RB_DEBUG_DB_PORT)
log::debug
{
db::log, "shared_mutex %lu %p UNLOCK",
ctx::id(),
this
};
assert_main_thread();
const ctx::uninterruptible::nothrow ui;
mu.unlock();
}
//
// CondVar
//
static_assert
(
sizeof(rocksdb::port::CondVar) <= sizeof(pthread_cond_t) + sizeof(void *),
"link-time punning of our structure won't work if the structure is larger "
"than the one rocksdb has assumed space for."
);
rocksdb::port::CondVar::CondVar(Mutex *mu)
noexcept
{
memset(this, 0x0, sizeof(pthread_cond_t) + sizeof(Mutex *));
this->mu = mu;
if constexpr(RB_DEBUG_DB_PORT > 1)
{
if(unlikely(!ctx::current))
return;
log::debug
{
db::log, "cond %lu %p %p CTOR",
ctx::id(),
this,
mu
};
}
}
rocksdb::port::CondVar::~CondVar()
noexcept
{
if constexpr(RB_DEBUG_DB_PORT > 1)
{
if(unlikely(!ctx::current))
return;
log::debug
{
db::log, "cond %lu %p %p DTOR",
ctx::id(),
this,
mu
};
}
}
void
rocksdb::port::CondVar::Wait()
noexcept
{
assert(ctx::current);
if constexpr(RB_DEBUG_DB_PORT)
log::debug
{
db::log, "cond %lu %p %p WAIT",
ctx::id(),
this,
mu
};
assert(mu);
assert_main_thread();
mu->AssertHeld();
const ctx::uninterruptible::nothrow ui;
cv.wait(mu->mu);
}
// Returns true if timeout occurred
bool
rocksdb::port::CondVar::TimedWait(uint64_t abs_time_us)
noexcept
{
assert(ctx::current);
if constexpr(RB_DEBUG_DB_PORT)
log::debug
{
db::log, "cond %lu %p %p WAIT_UNTIL %lu",
ctx::id(),
this,
mu,
abs_time_us
};
assert(mu);
assert_main_thread();
mu->AssertHeld();
const std::chrono::microseconds us(abs_time_us);
const std::chrono::system_clock::time_point tp(us);
const ctx::uninterruptible::nothrow ui;
return cv.wait_until(mu->mu, tp) == std::cv_status::timeout;
}
void
rocksdb::port::CondVar::Signal()
noexcept
{
if constexpr(RB_DEBUG_DB_PORT)
log::debug
{
db::log, "cond %lu %p %p NOTIFY",
ctx::id(),
this,
mu
};
assert_main_thread();
cv.notify_one();
}
void
rocksdb::port::CondVar::SignalAll()
noexcept
{
if constexpr(RB_DEBUG_DB_PORT)
log::debug
{
db::log, "cond %lu %p %p BROADCAST",
ctx::id(),
this,
mu
};
assert_main_thread();
cv.notify_all();
}