void CBDB_Env::SetTasSpins(unsigned tas_spins)
{
#ifdef BDB_NEW_MUTEX_API
int ret = m_Env->mutex_set_tas_spins(m_Env, tas_spins);
BDB_CHECK(ret, "DB_ENV::mutex_set_tas_spins");
#else
int ret = m_Env->set_tas_spins(m_Env, tas_spins);
BDB_CHECK(ret, "DB_ENV::set_tas_spins");
#endif
}
void CBDB_Env::ForceRemove()
{
_ASSERT(!m_HomePath.empty());
Close();
int ret = db_env_create(&m_Env, 0);
BDB_CHECK(ret, "DB_ENV");
ret = m_Env->remove(m_Env, m_HomePath.c_str(), DB_FORCE);
m_Env = 0;
BDB_CHECK(ret, "DB_ENV::remove");
}
void CBDB_Env::OpenConcurrentDB(const string& db_home)
{
int ret = m_Env->set_flags(m_Env, DB_CDB_ALLDB, 1);
BDB_CHECK(ret, "DB_ENV::set_flags");
Open(db_home, DB_CREATE | DB_THREAD | DB_INIT_CDB | DB_INIT_MPOOL);
}
EBDB_ErrCode CBDB_LobFile::x_Put(unsigned int lob_id,
const void* data,
size_t size,
bool can_update)
{
_ASSERT(lob_id);
_ASSERT(size);
_ASSERT(m_DB);
// paranoia check
_ASSERT(m_DBT_Key->data == &m_LobKey);
_ASSERT(m_DBT_Key->size == sizeof(m_LobKey));
if (IsByteSwapped()) {
m_LobKey = (unsigned int) CByteSwap::GetInt4((unsigned char*)&lob_id);
} else {
m_LobKey = lob_id;
}
m_DBT_Data->data = const_cast<void*> (data);
m_DBT_Data->size = m_DBT_Data->ulen = (unsigned)size;
int ret = m_DB->put(m_DB,
0, // DB_TXN*
m_DBT_Key,
m_DBT_Data,
can_update?0:DB_NOOVERWRITE /*| DB_NODUPDATA*/
);
if (ret == DB_KEYEXIST)
return eBDB_KeyDup;
BDB_CHECK(ret, FileName().c_str());
return eBDB_Ok;
}
ERW_Result CBDB_BlobReaderWriter::Write(const void* buf,
size_t count,
size_t* bytes_written)
{
m_DBT_Data->flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
m_DBT_Data->data = const_cast<void*> (buf);
m_DBT_Data->size = (unsigned)count;
m_DBT_Data->ulen = (unsigned)count;
m_DBT_Data->doff = m_Pos;
m_DBT_Data->dlen = (unsigned)count;
int ret = m_DB->put(m_DB,
m_Txn,
m_DBT_Key,
m_DBT_Data,
0);
BDB_CHECK(ret, "CBDB_BlobReaderWriter");
m_Pos += (unsigned)count;
if (bytes_written) {
*bytes_written = count;
}
return eRW_Success;
}
void CBDB_Env::MutexSetMax(unsigned max)
{
#ifdef BDB_NEW_MUTEX_API
int ret = m_Env->mutex_set_max(m_Env, max);
BDB_CHECK(ret, "DB_ENV::mutex_set_max");
#endif
}
EBDB_ErrCode CBDB_LobFile::GetData(void* buf, size_t size)
{
_ASSERT(m_LobKey);
_ASSERT(m_DB);
_ASSERT(size >= m_DBT_Data->size);
_ASSERT(m_DBT_Data->size);
// paranoia check
_ASSERT(m_DBT_Key->data == &m_LobKey);
_ASSERT(m_DBT_Key->size == sizeof(m_LobKey));
_ASSERT(m_DBT_Key->ulen == sizeof(m_LobKey));
_ASSERT(m_DBT_Key->flags == DB_DBT_USERMEM);
m_DBT_Data->data = buf;
m_DBT_Data->ulen = (unsigned)size;
m_DBT_Data->flags = DB_DBT_USERMEM;
int ret = m_DB->get(m_DB,
0, // DB_TXN*
m_DBT_Key,
m_DBT_Data,
0
);
if (ret == DB_NOTFOUND)
return eBDB_NotFound;
BDB_CHECK(ret, FileName().c_str());
return eBDB_Ok;
}
void CBDB_Env::PrintMutexStat(CNcbiOstream & out)
{
#ifdef BDB_NEW_MUTEX_API
DB_MUTEX_STAT* stp = 0;
try {
int ret = m_Env->mutex_stat(m_Env, &stp, 0);
BDB_CHECK(ret, "DB_ENV::mutex_stat");
out << "st_mutex_align : " << stp->st_mutex_align << NcbiEndl
<< "st_mutex_tas_spins : " << stp->st_mutex_tas_spins << NcbiEndl
<< "st_mutex_free : " << stp->st_mutex_free << NcbiEndl
<< "st_mutex_inuse : " << stp->st_mutex_inuse << NcbiEndl
<< "st_mutex_inuse_max : " << stp->st_mutex_inuse_max << NcbiEndl
<< "st_regsize : " << stp->st_regsize << NcbiEndl
<< "st_region_wait : " << stp->st_region_wait << NcbiEndl
<< "st_region_nowait : " << stp->st_region_nowait << NcbiEndl
;
}
catch (...)
{
if (stp) {
::free(stp);
}
throw;
}
if (stp) {
::free(stp);
}
#endif
}
void CLDS_File::UpdateEntry(int file_id,
const string& file_name,
Uint4 crc,
int time_stamp,
Int8 file_size,
bool compute_check_sum)
{
if (!crc && compute_check_sum) {
crc = ComputeFileCRC32(file_name);
}
m_FileDB.file_id = file_id;
if (m_FileDB.Fetch() != eBDB_Ok) {
LDS_THROW(eRecordNotFound, "Files record not found");
}
// Re-evalute the file format
CFormatGuess fg;
CFormatGuess::EFormat format = fg.Format(file_name);
m_FileDB.format = format;
m_FileDB.time_stamp = time_stamp;
m_FileDB.CRC = crc;
m_FileDB.file_size = file_size;
EBDB_ErrCode err = m_FileDB.UpdateInsert();
BDB_CHECK(err, "LDS::File");
LOG_POST_X(5, Info << "LDS: file update: " << file_name);
}
size_t CBDB_Env::GetMpMmapSize()
{
size_t map_size = 0;
int ret = m_Env->get_mp_mmapsize(m_Env, &map_size);
BDB_CHECK(ret, "DB_ENV::get_mp_mmapsize");
return map_size;
}
void CBDB_Env::MutexSetIncrement(unsigned inc)
{
#ifdef BDB_NEW_MUTEX_API
int ret = m_Env->mutex_set_increment(m_Env, inc);
BDB_CHECK(ret, "DB_ENV::mutex_set_increment");
#endif
}
DB_TXN* CBDB_Env::CreateTxn(DB_TXN* parent_txn, unsigned int flags)
{
DB_TXN* txn = 0;
int ret = m_Env->txn_begin(m_Env, parent_txn, &txn, flags);
BDB_CHECK(ret, "DB_ENV::txn_begin");
return txn;
}
void CBDB_Env::SetMaxLocks(unsigned locks)
{
m_MaxLocks = locks;
if (m_Env) {
int ret = m_Env->set_lk_max_locks(m_Env, locks);
BDB_CHECK(ret, "DB_ENV::set_lk_max_locks");
}
}
void CBDB_Env::TransactionCheckpoint()
{
if (m_CheckPointEnable && IsTransactional()) {
int ret =
m_Env->txn_checkpoint(m_Env, m_CheckPointKB, m_CheckPointMin, 0);
BDB_CHECK(ret, "DB_ENV::txn_checkpoint");
}
}
void CBDB_Env::Close()
{
if (m_Env) {
int ret = m_Env->close(m_Env, 0);
m_Env = 0;
BDB_CHECK(ret, "DB_ENV::close");
}
}
void CBDB_Env::SetMaxLockers(unsigned max_lockers)
{
m_MaxLockers = max_lockers;
if (m_Env) {
int ret = m_Env->set_lk_max_lockers(m_Env, max_lockers);
BDB_CHECK(ret, "DB_ENV::set_lk_max_lockers");
}
}
void CBDB_Env::SetMaxLockObjects(unsigned lock_obj_max)
{
m_MaxLockObjects = lock_obj_max;
if (m_Env) {
int ret = m_Env->set_lk_max_objects(m_Env, m_MaxLockObjects);
BDB_CHECK(ret, "DB_ENV::set_lk_max_objects");
}
}
void CBDB_Env::Open(const string& db_home, int flags)
{
int ret = x_Open(db_home.c_str(), flags);
BDB_CHECK(ret, "DB_ENV");
SetDirectDB(m_DirectDB);
SetDirectLog(m_DirectLOG);
}
void CBDB_Env::ForceTransactionCheckpoint()
{
if (IsTransactional()) {
int ret =
m_Env->txn_checkpoint(m_Env, 0, 0, DB_FORCE);
BDB_CHECK(ret, "DB_ENV::txn_checkpoint");
}
}
void db_multimap<K, T>::insert(const value_type& x)
{
this->m_Dbf.key = x.first;
this->m_Dbf.value = x.second;
EBDB_ErrCode ret = this->m_Dbf.Insert();
BDB_CHECK(ret, this->m_Dbf.GetFileName().c_str());
}
bool CBDB_Env::Remove()
{
if (m_HomePath.empty()) {
return true;
}
Close();
int ret = db_env_create(&m_Env, 0);
BDB_CHECK(ret, "DB_ENV");
ret = m_Env->remove(m_Env, m_HomePath.c_str(), 0);
m_Env = 0;
if (ret == EBUSY)
return false;
BDB_CHECK(ret, "DB_ENV::remove");
return true;
}
void CBDB_Env::DeadLockDetect()
{
if (m_DeadLockMode == eDeadLock_Disable) {
return;
}
u_int32_t detect = x_GetDeadLockDetect(m_DeadLockMode);
int aborted;
int ret = m_Env->lock_detect(m_Env, 0, detect, &aborted);
BDB_CHECK(ret, "lock_detect");
}
unsigned CBDB_Env::GetMaxLocks()
{
if (!m_Env)
return m_MaxLocks;
u_int32_t lk_max;
int ret = m_Env->get_lk_max_locks(m_Env, &lk_max);
BDB_CHECK(ret, "DB_ENV::get_lk_max_locks");
return lk_max;
}
void CBDB_Env::SetLkDetect(EDeadLockDetect detect_mode)
{
m_DeadLockMode = detect_mode;
if (m_DeadLockMode == eDeadLock_Disable) {
return;
}
u_int32_t detect = x_GetDeadLockDetect(detect_mode);
int ret = m_Env->set_lk_detect(m_Env, detect);
BDB_CHECK(ret, "DB_ENV::set_lk_detect");
}
unsigned CBDB_Env::MutexGetIncrement()
{
#ifdef BDB_NEW_MUTEX_API
u_int32_t inc;
int ret = m_Env->mutex_get_increment(m_Env, &inc);
BDB_CHECK(ret, "DB_ENV::mutex_get_increment");
return inc;
#else
return 0;
#endif
}
unsigned CBDB_Env::MutexGetMax()
{
#ifdef BDB_NEW_MUTEX_API
u_int32_t maxp;
int ret = m_Env->mutex_get_max(m_Env, &maxp);
BDB_CHECK(ret, "DB_ENV::mutex_get_max");
return maxp;
#else
return 0;
#endif
}
void CBDB_Env::SetCacheSize(Uint8 cache_size,
int num_caches)
{
unsigned cache_g = (unsigned) (cache_size / (Uint8)1073741824); // gig
if (cache_g) {
cache_size = cache_size % 1073741824;
}
unsigned ncache = max(num_caches, 1);
int ret =
m_Env->set_cachesize(m_Env, cache_g, (unsigned)cache_size, ncache);
BDB_CHECK(ret, 0);
}
void CBDB_Env::PrintLockStat(CNcbiOstream & out)
{
#ifdef BDB_NEW_MUTEX_API
DB_LOCK_STAT *stp = 0;
try {
int ret = m_Env->lock_stat(m_Env, &stp, 0);
BDB_CHECK(ret, "DB_ENV::lock_stat");
out << "st_id : " << stp->st_id << NcbiEndl
<< "st_cur_maxid : " << stp->st_cur_maxid << NcbiEndl
<< "st_nmodes : " << stp->st_nmodes << NcbiEndl
<< "st_maxlocks : " << stp->st_maxlocks << NcbiEndl
<< "st_maxlockers : " << stp->st_maxlockers << NcbiEndl
<< "st_maxobjects : " << stp->st_maxobjects << NcbiEndl
<< "st_nlocks : " << stp->st_nlocks << NcbiEndl
<< "st_maxnlocks : " << stp->st_maxnlocks << NcbiEndl
<< "st_nlockers : " << stp->st_nlockers << NcbiEndl
<< "st_maxnlockers : " << stp->st_maxnlockers << NcbiEndl
<< "st_nobjects : " << stp->st_nobjects << NcbiEndl
<< "st_maxnobjects : " << stp->st_maxnobjects << NcbiEndl
<< "st_nrequests : " << stp->st_nrequests << NcbiEndl
<< "st_nreleases : " << stp->st_nreleases << NcbiEndl
<< "st_nupgrade : " << stp->st_nupgrade << NcbiEndl
<< "st_ndowngrade : " << stp->st_ndowngrade << NcbiEndl
<< "st_lock_wait : " << stp->st_lock_wait << NcbiEndl
<< "st_lock_nowait : " << stp->st_lock_nowait << NcbiEndl
<< "st_ndeadlocks : " << stp->st_ndeadlocks << NcbiEndl
<< "st_locktimeout : " << stp->st_locktimeout << NcbiEndl
<< "st_nlocktimeouts: " << stp->st_nlocktimeouts << NcbiEndl
<< "st_txntimeout : " << stp->st_txntimeout << NcbiEndl
<< "st_ntxntimeouts : " << stp->st_ntxntimeouts << NcbiEndl
<< "st_regsize : " << stp->st_regsize << NcbiEndl
<< "st_region_wait : " << stp->st_region_wait << NcbiEndl
<< "st_region_nowait: " << stp->st_region_nowait << NcbiEndl
;
}
catch (...)
{
if (stp) {
::free(stp);
}
throw;
}
if (stp) {
::free(stp);
}
#endif
}
void CBDB_Env::MempTrickle(int percent, int *nwrotep)
{
int nwr;
int ret = m_Env->memp_trickle(m_Env, percent, &nwr);
BDB_CHECK(ret, "DB_ENV::memp_trickle");
if (nwrotep) {
*nwrotep = nwr;
}
if (m_Monitor && m_Monitor->IsActive()) {
string msg = "BDB_ENV: memp_tricle ";
msg += NStr::IntToString(percent);
msg += "% written ";
msg += NStr::IntToString(nwr);
msg += " pages.";
m_Monitor->Send(msg);
}
}
void CBDB_Env::CleanLog()
{
char **nm_list = 0;
int ret =
m_Env->log_archive(m_Env, &nm_list, DB_ARCH_ABS);
BDB_CHECK(ret, "DB_ENV::CleanLog()");
if (nm_list != NULL) {
for (char** file = nm_list; *file != NULL; ++file) {
LOG_POST_X(5, Info << "BDB_Env: Removing LOG file: " << *file);
CDirEntry de(*file);
de.Remove();
}
free(nm_list);
}
}
