@ -1,4 +1,4 @@
// Copyright (c) 2013 , Facebook, Inc. All rights reserved.
// Copyright (c) 2011-present , Facebook, Inc. All rights reserved.
// This source code is licensed under the BSD-style license found in the
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree. An additional grant
// LICENSE file in the root directory of this source tree. An additional grant
// of patent rights can be found in the PATENTS file in the same directory.
// of patent rights can be found in the PATENTS file in the same directory.
@ -15,6 +15,9 @@
# include <inttypes.h> # include <inttypes.h>
# include <stdint.h> # include <stdint.h>
# ifdef OS_SOLARIS
# include <alloca.h>
# endif
# include <algorithm> # include <algorithm>
# include <climits> # include <climits>
@ -28,8 +31,10 @@
# include <utility> # include <utility>
# include <vector> # include <vector>
# include "db/auto_roll_logger.h"
# include "db/builder.h" # include "db/builder.h"
# include "db/compaction_job.h" # include "db/compaction_job.h"
# include "db/db_info_dumper.h"
# include "db/db_iter.h" # include "db/db_iter.h"
# include "db/dbformat.h" # include "db/dbformat.h"
# include "db/event_helpers.h" # include "db/event_helpers.h"
@ -51,6 +56,7 @@
# include "db/write_batch_internal.h" # include "db/write_batch_internal.h"
# include "db/write_callback.h" # include "db/write_callback.h"
# include "db/writebuffer.h" # include "db/writebuffer.h"
# include "db/xfunc_test_points.h"
# include "memtable/hash_linklist_rep.h" # include "memtable/hash_linklist_rep.h"
# include "memtable/hash_skiplist_rep.h" # include "memtable/hash_skiplist_rep.h"
# include "port/likely.h" # include "port/likely.h"
@ -58,7 +64,6 @@
# include "rocksdb/cache.h" # include "rocksdb/cache.h"
# include "rocksdb/compaction_filter.h" # include "rocksdb/compaction_filter.h"
# include "rocksdb/db.h" # include "rocksdb/db.h"
# include "rocksdb/delete_scheduler.h"
# include "rocksdb/env.h" # include "rocksdb/env.h"
# include "rocksdb/merge_operator.h" # include "rocksdb/merge_operator.h"
# include "rocksdb/sst_file_writer.h" # include "rocksdb/sst_file_writer.h"
@ -72,19 +77,18 @@
# include "table/merger.h" # include "table/merger.h"
# include "table/table_builder.h" # include "table/table_builder.h"
# include "table/two_level_iterator.h" # include "table/two_level_iterator.h"
# include "util/auto_roll_logger.h"
# include "util/autovector.h" # include "util/autovector.h"
# include "util/build_version.h" # include "util/build_version.h"
# include "util/coding.h" # include "util/coding.h"
# include "util/compression.h" # include "util/compression.h"
# include "util/crc32c.h" # include "util/crc32c.h"
# include "util/db_info_dumper.h"
# include "util/file_reader_writer.h" # include "util/file_reader_writer.h"
# include "util/file_util.h" # include "util/file_util.h"
# include "util/iostats_context_imp.h" # include "util/iostats_context_imp.h"
# include "util/log_buffer.h" # include "util/log_buffer.h"
# include "util/logging.h" # include "util/logging.h"
# include "util/mutexlock.h" # include "util/mutexlock.h"
# include "util/sst_file_manager_impl.h"
# include "util/options_helper.h" # include "util/options_helper.h"
# include "util/options_parser.h" # include "util/options_parser.h"
# include "util/perf_context_imp.h" # include "util/perf_context_imp.h"
@ -142,6 +146,12 @@ DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src) {
result . info_log = nullptr ; result . info_log = nullptr ;
} }
} }
if ( result . base_background_compactions = = - 1 ) {
result . base_background_compactions = result . max_background_compactions ;
}
if ( result . base_background_compactions > result . max_background_compactions ) {
result . base_background_compactions = result . max_background_compactions ;
}
result . env - > IncBackgroundThreadsIfNeeded ( src . max_background_compactions , result . env - > IncBackgroundThreadsIfNeeded ( src . max_background_compactions ,
Env : : Priority : : LOW ) ; Env : : Priority : : LOW ) ;
result . env - > IncBackgroundThreadsIfNeeded ( src . max_background_flushes , result . env - > IncBackgroundThreadsIfNeeded ( src . max_background_flushes ,
@ -265,13 +275,14 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname)
db_options_ . delete_obsolete_files_period_micros ) , db_options_ . delete_obsolete_files_period_micros ) ,
last_stats_dump_time_microsec_ ( 0 ) , last_stats_dump_time_microsec_ ( 0 ) ,
next_job_id_ ( 1 ) , next_job_id_ ( 1 ) ,
flush_on_destroy _( false ) , has_unpersisted_data _( false ) ,
env_options_ ( db_options_ ) , env_options_ ( db_options_ ) ,
# ifndef ROCKSDB_LITE # ifndef ROCKSDB_LITE
wal_manager_ ( db_options_ , env_options_ ) , wal_manager_ ( db_options_ , env_options_ ) ,
# endif // ROCKSDB_LITE
# endif // ROCKSDB_LITE
event_logger_ ( db_options_ . info_log . get ( ) ) , event_logger_ ( db_options_ . info_log . get ( ) ) ,
bg_work_paused_ ( 0 ) , bg_work_paused_ ( 0 ) ,
bg_compaction_paused_ ( 0 ) ,
refitting_level_ ( false ) , refitting_level_ ( false ) ,
opened_successfully_ ( false ) { opened_successfully_ ( false ) {
env_ - > GetAbsolutePath ( dbname , & db_absolute_path_ ) ; env_ - > GetAbsolutePath ( dbname , & db_absolute_path_ ) ;
@ -312,7 +323,8 @@ void DBImpl::CancelAllBackgroundWork(bool wait) {
DBImpl : : ~ DBImpl ( ) { DBImpl : : ~ DBImpl ( ) {
mutex_ . Lock ( ) ; mutex_ . Lock ( ) ;
if ( ! shutting_down_ . load ( std : : memory_order_acquire ) & & flush_on_destroy_ ) { if ( ! shutting_down_ . load ( std : : memory_order_acquire ) & &
has_unpersisted_data_ ) {
for ( auto cfd : * versions_ - > GetColumnFamilySet ( ) ) { for ( auto cfd : * versions_ - > GetColumnFamilySet ( ) ) {
if ( ! cfd - > IsDropped ( ) & & ! cfd - > mem ( ) - > IsEmpty ( ) ) { if ( ! cfd - > IsDropped ( ) & & ! cfd - > mem ( ) - > IsEmpty ( ) ) {
cfd - > Ref ( ) ; cfd - > Ref ( ) ;
@ -484,23 +496,22 @@ void DBImpl::MaybeDumpStats() {
last_stats_dump_time_microsec_ = now_micros ; last_stats_dump_time_microsec_ = now_micros ;
# ifndef ROCKSDB_LITE # ifndef ROCKSDB_LITE
bool tmp1 = false ; const DBPropertyInfo * cf_property_info =
bool tmp2 = false ; GetPropertyInfo ( DB : : Properties : : kCFStats ) ;
DBPropertyType cf_property_type = assert ( cf_property_info ! = nullptr ) ;
GetPropertyType ( DB : : Properties : : kCFStats , & tmp1 , & tmp2 ) ; const DBPropertyInfo * db_property_info =
DBPropertyType db_property_type = GetPropertyInfo ( DB : : Properties : : kDBStats ) ;
GetPropertyType ( DB : : Properties : : kDBStats , & tmp1 , & tmp2 ) ; assert ( db_property_info ! = nullptr ) ;
std : : string stats ; std : : string stats ;
{ {
InstrumentedMutexLock l ( & mutex_ ) ; InstrumentedMutexLock l ( & mutex_ ) ;
for ( auto cfd : * versions_ - > GetColumnFamilySet ( ) ) { for ( auto cfd : * versions_ - > GetColumnFamilySet ( ) ) {
cfd - > internal_stats ( ) - > GetStringProperty ( cf_property_type , cfd - > internal_stats ( ) - > GetStringProperty (
DB : : Properties : : kCFStats , * cf_property_info , DB : : Properties : : kCFStats , & stats ) ;
& stats ) ;
} }
default_cf_internal_stats_ - > GetStringProperty ( db_property_type , default_cf_internal_stats_ - > GetStringProperty (
DB : : Properties : : kDBStats , * db_property_info , DB : : Properties : : kDBStats , & stats ) ;
& stats ) ;
} }
Log ( InfoLogLevel : : WARN_LEVEL , Log ( InfoLogLevel : : WARN_LEVEL ,
db_options_ . info_log , " ------- DUMPING STATS ------- " ) ; db_options_ . info_log , " ------- DUMPING STATS ------- " ) ;
@ -561,6 +572,7 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
// Get obsolete files. This function will also update the list of
// Get obsolete files. This function will also update the list of
// pending files in VersionSet().
// pending files in VersionSet().
versions_ - > GetObsoleteFiles ( & job_context - > sst_delete_files , versions_ - > GetObsoleteFiles ( & job_context - > sst_delete_files ,
& job_context - > manifest_delete_files ,
job_context - > min_pending_output ) ; job_context - > min_pending_output ) ;
// store the current filenum, lognum, etc
// store the current filenum, lognum, etc
@ -678,9 +690,9 @@ void DBImpl::PurgeObsoleteFiles(const JobContext& state) {
} }
auto candidate_files = state . full_scan_candidate_files ; auto candidate_files = state . full_scan_candidate_files ;
candidate_files . reserve ( candidate_files . size ( ) + candidate_files . reserve (
state . sst_delete_files . size ( ) + candidate_files . size ( ) + state . sst_delete_files . size ( ) +
state . log _delete_files . size ( ) ) ; state . log_delete_files . size ( ) + state . manifest _delete_files. size ( ) ) ;
// We may ignore the dbname when generating the file names.
// We may ignore the dbname when generating the file names.
const char * kDumbDbName = " " ; const char * kDumbDbName = " " ;
for ( auto file : state . sst_delete_files ) { for ( auto file : state . sst_delete_files ) {
@ -696,6 +708,9 @@ void DBImpl::PurgeObsoleteFiles(const JobContext& state) {
0 ) ; 0 ) ;
} }
} }
for ( const auto & filename : state . manifest_delete_files ) {
candidate_files . emplace_back ( filename , 0 ) ;
}
// dedup state.candidate_files so we don't try to delete the same
// dedup state.candidate_files so we don't try to delete the same
// file twice
// file twice
@ -782,8 +797,8 @@ void DBImpl::PurgeObsoleteFiles(const JobContext& state) {
} }
# endif // !ROCKSDB_LITE
# endif // !ROCKSDB_LITE
Status file_deletion_status ; Status file_deletion_status ;
if ( type = = kTableFile & & path_id = = 0 ) { if ( type = = kTableFile ) {
file_deletion_status = DeleteOrMoveToTrash ( & db_options_ , fname ) ; file_deletion_status = DeleteSSTFile ( & db_options_ , fname , path_id ) ;
} else { } else {
file_deletion_status = env_ - > DeleteFile ( fname ) ; file_deletion_status = env_ - > DeleteFile ( fname ) ;
} }
@ -814,7 +829,8 @@ void DBImpl::PurgeObsoleteFiles(const JobContext& state) {
// Delete old info log files.
// Delete old info log files.
size_t old_info_log_file_count = old_info_log_files . size ( ) ; size_t old_info_log_file_count = old_info_log_files . size ( ) ;
if ( old_info_log_file_count > = db_options_ . keep_log_file_num ) { if ( old_info_log_file_count ! = 0 & &
old_info_log_file_count > = db_options_ . keep_log_file_num ) {
std : : sort ( old_info_log_files . begin ( ) , old_info_log_files . end ( ) ) ; std : : sort ( old_info_log_files . begin ( ) , old_info_log_files . end ( ) ) ;
size_t end = old_info_log_file_count - db_options_ . keep_log_file_num ; size_t end = old_info_log_file_count - db_options_ . keep_log_file_num ;
for ( unsigned int i = 0 ; i < = end ; i + + ) { for ( unsigned int i = 0 ; i < = end ; i + + ) {
@ -1393,9 +1409,9 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
mutex_ . AssertHeld ( ) ; mutex_ . AssertHeld ( ) ;
const uint64_t start_micros = env_ - > NowMicros ( ) ; const uint64_t start_micros = env_ - > NowMicros ( ) ;
FileMetaData meta ; FileMetaData meta ;
meta . fd = FileDescriptor ( versions_ - > NewFileNumber ( ) , 0 , 0 ) ;
auto pending_outputs_inserted_elem = auto pending_outputs_inserted_elem =
CaptureCurrentFileNumberInPendingOutputs ( ) ; CaptureCurrentFileNumberInPendingOutputs ( ) ;
meta . fd = FileDescriptor ( versions_ - > NewFileNumber ( ) , 0 , 0 ) ;
ReadOptions ro ; ReadOptions ro ;
ro . total_order_seek = true ; ro . total_order_seek = true ;
Arena arena ; Arena arena ;
@ -1517,13 +1533,26 @@ Status DBImpl::FlushMemTableToOutputFile(
bg_error_ = s ; bg_error_ = s ;
} }
RecordFlushIOStats ( ) ; RecordFlushIOStats ( ) ;
# ifndef ROCKSDB_LITE
if ( s . ok ( ) ) { if ( s . ok ( ) ) {
# ifndef ROCKSDB_LITE
// may temporarily unlock and lock the mutex.
// may temporarily unlock and lock the mutex.
NotifyOnFlushCompleted ( cfd , & file_meta , mutable_cf_options , NotifyOnFlushCompleted ( cfd , & file_meta , mutable_cf_options ,
job_context - > job_id , flush_job . GetTableProperties ( ) ) ; job_context - > job_id , flush_job . GetTableProperties ( ) ) ;
}
# endif // ROCKSDB_LITE
# endif // ROCKSDB_LITE
auto sfm =
static_cast < SstFileManagerImpl * > ( db_options_ . sst_file_manager . get ( ) ) ;
if ( sfm ) {
// Notify sst_file_manager that a new file was added
std : : string file_path = MakeTableFileName ( db_options_ . db_paths [ 0 ] . path ,
file_meta . fd . GetNumber ( ) ) ;
sfm - > OnAddFile ( file_path ) ;
if ( sfm - > IsMaxAllowedSpaceReached ( ) & & bg_error_ . ok ( ) ) {
bg_error_ = Status : : IOError ( " Max allowed space was reached " ) ;
TEST_SYNC_POINT (
" DBImpl::FlushMemTableToOutputFile:MaxAllowedSpaceReached " ) ;
}
}
}
return s ; return s ;
} }
@ -1813,13 +1842,16 @@ Status DBImpl::CompactFilesImpl(
std : : vector < SequenceNumber > snapshot_seqs = std : : vector < SequenceNumber > snapshot_seqs =
snapshots_ . GetAll ( & earliest_write_conflict_snapshot ) ; snapshots_ . GetAll ( & earliest_write_conflict_snapshot ) ;
auto pending_outputs_inserted_elem =
CaptureCurrentFileNumberInPendingOutputs ( ) ;
assert ( is_snapshot_supported_ | | snapshots_ . empty ( ) ) ; assert ( is_snapshot_supported_ | | snapshots_ . empty ( ) ) ;
CompactionJob compaction_job ( CompactionJob compaction_job (
job_context - > job_id , c . get ( ) , db_options_ , env_options_ , versions_ . get ( ) , job_context - > job_id , c . get ( ) , db_options_ , env_options_ , versions_ . get ( ) ,
& shutting_down_ , log_buffer , directories_ . GetDbDir ( ) , & shutting_down_ , log_buffer , directories_ . GetDbDir ( ) ,
directories_ . GetDataDir ( c - > output_path_id ( ) ) , stats_ , snapshot_seqs , directories_ . GetDataDir ( c - > output_path_id ( ) ) , stats_ , & mutex_ , & bg_error_ ,
earliest_write_conflict_snapshot , table_cache_ , & event_logger _ , snapshot_seqs , earliest_write_conflict_snapshot , table_cache_ ,
c - > mutable_cf_options ( ) - > paranoid_file_checks , & event_logger_ , c - > mutable_cf_options ( ) - > paranoid_file_checks ,
c - > mutable_cf_options ( ) - > compaction_measure_io_stats , dbname_ , c - > mutable_cf_options ( ) - > compaction_measure_io_stats , dbname_ ,
nullptr ) ; // Here we pass a nullptr for CompactionJobStats because
nullptr ) ; // Here we pass a nullptr for CompactionJobStats because
// CompactFiles does not trigger OnCompactionCompleted(),
// CompactFiles does not trigger OnCompactionCompleted(),
@ -1834,21 +1866,35 @@ Status DBImpl::CompactFilesImpl(
// support for CompactFiles, we should have CompactFiles API
// support for CompactFiles, we should have CompactFiles API
// pass a pointer of CompactionJobStats as the out-value
// pass a pointer of CompactionJobStats as the out-value
// instead of using EventListener.
// instead of using EventListener.
// Creating a compaction influences the compaction score because the score
// takes running compactions into account (by skipping files that are already
// being compacted). Since we just changed compaction score, we recalculate it
// here.
{
CompactionOptionsFIFO dummy_compaction_options_fifo ;
version - > storage_info ( ) - > ComputeCompactionScore (
* c - > mutable_cf_options ( ) , dummy_compaction_options_fifo ) ;
}
compaction_job . Prepare ( ) ; compaction_job . Prepare ( ) ;
mutex_ . Unlock ( ) ; mutex_ . Unlock ( ) ;
TEST_SYNC_POINT ( " CompactFilesImpl:0 " ) ; TEST_SYNC_POINT ( " CompactFilesImpl:0 " ) ;
TEST_SYNC_POINT ( " CompactFilesImpl:1 " ) ; TEST_SYNC_POINT ( " CompactFilesImpl:1 " ) ;
compaction_job . Run ( ) ; compaction_job . Run ( ) ;
TEST_SYNC_POINT ( " CompactFilesImpl:2 " ) ;
TEST_SYNC_POINT ( " CompactFilesImpl:3 " ) ;
mutex_ . Lock ( ) ; mutex_ . Lock ( ) ;
Status status = compaction_job . Install ( * c - > mutable_cf_options ( ) , & mutex_ ) ; Status status = compaction_job . Install ( * c - > mutable_cf_options ( ) ) ;
if ( status . ok ( ) ) { if ( status . ok ( ) ) {
InstallSuperVersionAndScheduleWorkWrapper ( InstallSuperVersionAndScheduleWorkWrapper (
c - > column_family_data ( ) , job_context , * c - > mutable_cf_options ( ) ) ; c - > column_family_data ( ) , job_context , * c - > mutable_cf_options ( ) ) ;
} }
c - > ReleaseCompactionFiles ( s ) ; c - > ReleaseCompactionFiles ( s ) ;
c . reset ( ) ;
ReleaseFileNumberFromPendingOutputs ( pending_outputs_inserted_elem ) ;
if ( status . ok ( ) ) { if ( status . ok ( ) ) {
// Done
// Done
@ -1864,6 +1910,8 @@ Status DBImpl::CompactFilesImpl(
} }
} }
c . reset ( ) ;
bg_compaction_scheduled_ - - ; bg_compaction_scheduled_ - - ;
if ( bg_compaction_scheduled_ = = 0 ) { if ( bg_compaction_scheduled_ = = 0 ) {
bg_cv_ . SignalAll ( ) ; bg_cv_ . SignalAll ( ) ;
@ -1875,10 +1923,11 @@ Status DBImpl::CompactFilesImpl(
Status DBImpl : : PauseBackgroundWork ( ) { Status DBImpl : : PauseBackgroundWork ( ) {
InstrumentedMutexLock guard_lock ( & mutex_ ) ; InstrumentedMutexLock guard_lock ( & mutex_ ) ;
bg_work _paused_ + + ; bg_compaction _paused_ + + ;
while ( bg_compaction_scheduled_ > 0 | | bg_flush_scheduled_ > 0 ) { while ( bg_compaction_scheduled_ > 0 | | bg_flush_scheduled_ > 0 ) {
bg_cv_ . Wait ( ) ; bg_cv_ . Wait ( ) ;
} }
bg_work_paused_ + + ;
return Status : : OK ( ) ; return Status : : OK ( ) ;
} }
@ -1888,7 +1937,11 @@ Status DBImpl::ContinueBackgroundWork() {
return Status : : InvalidArgument ( ) ; return Status : : InvalidArgument ( ) ;
} }
assert ( bg_work_paused_ > 0 ) ; assert ( bg_work_paused_ > 0 ) ;
assert ( bg_compaction_paused_ > 0 ) ;
bg_compaction_paused_ - - ;
bg_work_paused_ - - ; bg_work_paused_ - - ;
// It's sufficient to check just bg_work_paused_ here since
// bg_work_paused_ is always no greater than bg_compaction_paused_
if ( bg_work_paused_ = = 0 ) { if ( bg_work_paused_ = = 0 ) {
MaybeScheduleFlushOrCompaction ( ) ; MaybeScheduleFlushOrCompaction ( ) ;
} }
@ -2188,6 +2241,9 @@ Status DBImpl::SyncWAL() {
status = directories_ . GetWalDir ( ) - > Fsync ( ) ; status = directories_ . GetWalDir ( ) - > Fsync ( ) ;
} }
TEST_SYNC_POINT ( " DBImpl::SyncWAL:BeforeMarkLogsSynced:1 " ) ;
TEST_SYNC_POINT ( " DBImpl::SyncWAL:BeforeMarkLogsSynced:2 " ) ;
{ {
InstrumentedMutexLock l ( & mutex_ ) ; InstrumentedMutexLock l ( & mutex_ ) ;
MarkLogsSynced ( current_log_number , need_log_dir_sync , status ) ; MarkLogsSynced ( current_log_number , need_log_dir_sync , status ) ;
@ -2215,7 +2271,8 @@ void DBImpl::MarkLogsSynced(
+ + it ; + + it ;
} }
} }
assert ( logs_ . empty ( ) | | ( logs_ . size ( ) = = 1 & & ! logs_ [ 0 ] . getting_synced ) ) ; assert ( logs_ . empty ( ) | | logs_ [ 0 ] . number > up_to | |
( logs_ . size ( ) = = 1 & & ! logs_ [ 0 ] . getting_synced ) ) ;
log_sync_cv_ . SignalAll ( ) ; log_sync_cv_ . SignalAll ( ) ;
} }
@ -2453,25 +2510,32 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
env_ - > Schedule ( & DBImpl : : BGWorkFlush , this , Env : : Priority : : HIGH , this ) ; env_ - > Schedule ( & DBImpl : : BGWorkFlush , this , Env : : Priority : : HIGH , this ) ;
} }
auto bg_compactions_allowed = BGCompactionsAllowed ( ) ;
// special case -- if max_background_flushes == 0, then schedule flush on a
// special case -- if max_background_flushes == 0, then schedule flush on a
// compaction thread
// compaction thread
if ( db_options_ . max_background_flushes = = 0 ) { if ( db_options_ . max_background_flushes = = 0 ) {
while ( unscheduled_flushes_ > 0 & & while ( unscheduled_flushes_ > 0 & &
bg_flush_scheduled_ + bg_compaction_scheduled_ < bg_flush_scheduled_ + bg_compaction_scheduled_ <
db_options_ . max_background_compactions ) { bg_compactions_allowed ) {
unscheduled_flushes_ - - ; unscheduled_flushes_ - - ;
bg_flush_scheduled_ + + ; bg_flush_scheduled_ + + ;
env_ - > Schedule ( & DBImpl : : BGWorkFlush , this , Env : : Priority : : LOW , this ) ; env_ - > Schedule ( & DBImpl : : BGWorkFlush , this , Env : : Priority : : LOW , this ) ;
} }
} }
if ( bg_compaction_paused_ > 0 ) {
// we paused the background compaction
return ;
}
if ( HasExclusiveManualCompaction ( ) ) { if ( HasExclusiveManualCompaction ( ) ) {
// only manual compactions are allowed to run. don't schedule automatic
// only manual compactions are allowed to run. don't schedule automatic
// compactions
// compactions
return ; return ;
} }
while ( bg_compaction_scheduled_ < db_options_ . max_background_compactions & & while ( bg_compaction_scheduled_ < bg_compactions_allowed & &
unscheduled_compactions_ > 0 ) { unscheduled_compactions_ > 0 ) {
CompactionArg * ca = new CompactionArg ; CompactionArg * ca = new CompactionArg ;
ca - > db = this ; ca - > db = this ;
@ -2483,6 +2547,14 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
} }
} }
int DBImpl : : BGCompactionsAllowed ( ) const {
if ( write_controller_ . NeedSpeedupCompaction ( ) ) {
return db_options_ . max_background_compactions ;
} else {
return db_options_ . base_background_compactions ;
}
}
void DBImpl : : AddToCompactionQueue ( ColumnFamilyData * cfd ) { void DBImpl : : AddToCompactionQueue ( ColumnFamilyData * cfd ) {
assert ( ! cfd - > pending_compaction ( ) ) ; assert ( ! cfd - > pending_compaction ( ) ) ;
cfd - > Ref ( ) ; cfd - > Ref ( ) ;
@ -2595,10 +2667,10 @@ Status DBImpl::BackgroundFlush(bool* made_progress, JobContext* job_context,
LogToBuffer ( LogToBuffer (
log_buffer , log_buffer ,
" Calling FlushMemTableToOutputFile with column " " Calling FlushMemTableToOutputFile with column "
" family [%s], flush slots available %d, compaction slots avai lab le %d " , " family [%s], flush slots available %d, compaction slots allow ed %d, "
cfd - > GetName ( ) . c_str ( ) , " compaction slots scheduled %d " ,
db_options_ . max_background_flushes - bg_flush_scheduled_ , cfd - > GetName ( ) . c_str ( ) , db_options_ . max_background_flushes ,
db_options_ . max_background_compactions - bg_compaction_scheduled_ ) ; bg_flush_scheduled_ , BGCompactionsAllowed ( ) - bg_compaction_scheduled_ ) ;
status = FlushMemTableToOutputFile ( cfd , mutable_cf_options , made_progress , status = FlushMemTableToOutputFile ( cfd , mutable_cf_options , made_progress ,
job_context , log_buffer ) ; job_context , log_buffer ) ;
if ( cfd - > Unref ( ) ) { if ( cfd - > Unref ( ) ) {
@ -2911,7 +2983,9 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
TEST_SYNC_POINT ( " DBImpl::BackgroundCompaction:TrivialMove " ) ; TEST_SYNC_POINT ( " DBImpl::BackgroundCompaction:TrivialMove " ) ;
// Instrument for event update
// Instrument for event update
// TODO(yhchiang): add op details for showing trivial-move.
// TODO(yhchiang): add op details for showing trivial-move.
ThreadStatusUtil : : SetColumnFamily ( c - > column_family_data ( ) ) ; ThreadStatusUtil : : SetColumnFamily (
c - > column_family_data ( ) , c - > column_family_data ( ) - > ioptions ( ) - > env ,
c - > column_family_data ( ) - > options ( ) - > enable_thread_tracking ) ;
ThreadStatusUtil : : SetThreadOperation ( ThreadStatus : : OP_COMPACTION ) ; ThreadStatusUtil : : SetThreadOperation ( ThreadStatus : : OP_COMPACTION ) ;
compaction_job_stats . num_input_files = c - > num_input_files ( 0 ) ; compaction_job_stats . num_input_files = c - > num_input_files ( 0 ) ;
@ -2980,8 +3054,9 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
CompactionJob compaction_job ( CompactionJob compaction_job (
job_context - > job_id , c . get ( ) , db_options_ , env_options_ , job_context - > job_id , c . get ( ) , db_options_ , env_options_ ,
versions_ . get ( ) , & shutting_down_ , log_buffer , directories_ . GetDbDir ( ) , versions_ . get ( ) , & shutting_down_ , log_buffer , directories_ . GetDbDir ( ) ,
directories_ . GetDataDir ( c - > output_path_id ( ) ) , stats_ , snapshot_seqs , directories_ . GetDataDir ( c - > output_path_id ( ) ) , stats_ , & mutex_ ,
earliest_write_conflict_snapshot , table_cache_ , & event_logger_ , & bg_error_ , snapshot_seqs , earliest_write_conflict_snapshot ,
table_cache_ , & event_logger_ ,
c - > mutable_cf_options ( ) - > paranoid_file_checks , c - > mutable_cf_options ( ) - > paranoid_file_checks ,
c - > mutable_cf_options ( ) - > compaction_measure_io_stats , dbname_ , c - > mutable_cf_options ( ) - > compaction_measure_io_stats , dbname_ ,
& compaction_job_stats ) ; & compaction_job_stats ) ;
@ -2992,7 +3067,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
TEST_SYNC_POINT ( " DBImpl::BackgroundCompaction:NonTrivial:AfterRun " ) ; TEST_SYNC_POINT ( " DBImpl::BackgroundCompaction:NonTrivial:AfterRun " ) ;
mutex_ . Lock ( ) ; mutex_ . Lock ( ) ;
status = compaction_job . Install ( * c - > mutable_cf_options ( ) , & mutex_ ) ; status = compaction_job . Install ( * c - > mutable_cf_options ( ) ) ;
if ( status . ok ( ) ) { if ( status . ok ( ) ) {
InstallSuperVersionAndScheduleWorkWrapper ( InstallSuperVersionAndScheduleWorkWrapper (
c - > column_family_data ( ) , job_context , * c - > mutable_cf_options ( ) ) ; c - > column_family_data ( ) , job_context , * c - > mutable_cf_options ( ) ) ;
@ -3294,13 +3369,19 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
LookupKey lkey ( key , snapshot ) ; LookupKey lkey ( key , snapshot ) ;
PERF_TIMER_STOP ( get_snapshot_time ) ; PERF_TIMER_STOP ( get_snapshot_time ) ;
if ( sv - > mem - > Get ( lkey , value , & s , & merge_context ) ) { bool skip_memtable =
// Done
( read_options . read_tier = = kPersistedTier & & has_unpersisted_data_ ) ;
RecordTick ( stats_ , MEMTABLE_HIT ) ; bool done = false ;
} else if ( sv - > imm - > Get ( lkey , value , & s , & merge_context ) ) { if ( ! skip_memtable ) {
// Done
if ( sv - > mem - > Get ( lkey , value , & s , & merge_context ) ) {
RecordTick ( stats_ , MEMTABLE_HIT ) ; done = true ;
} else { RecordTick ( stats_ , MEMTABLE_HIT ) ;
} else if ( sv - > imm - > Get ( lkey , value , & s , & merge_context ) ) {
done = true ;
RecordTick ( stats_ , MEMTABLE_HIT ) ;
}
}
if ( ! done ) {
PERF_TIMER_GUARD ( get_from_output_files_time ) ; PERF_TIMER_GUARD ( get_from_output_files_time ) ;
sv - > current - > Get ( read_options , lkey , value , & s , & merge_context , sv - > current - > Get ( read_options , lkey , value , & s , & merge_context ,
value_found ) ; value_found ) ;
@ -3314,6 +3395,7 @@ Status DBImpl::GetImpl(const ReadOptions& read_options,
RecordTick ( stats_ , NUMBER_KEYS_READ ) ; RecordTick ( stats_ , NUMBER_KEYS_READ ) ;
RecordTick ( stats_ , BYTES_READ , value - > size ( ) ) ; RecordTick ( stats_ , BYTES_READ , value - > size ( ) ) ;
MeasureTime ( stats_ , BYTES_PER_READ , value - > size ( ) ) ;
} }
return s ; return s ;
} }
@ -3384,14 +3466,23 @@ std::vector<Status> DBImpl::MultiGet(
assert ( mgd_iter ! = multiget_cf_data . end ( ) ) ; assert ( mgd_iter ! = multiget_cf_data . end ( ) ) ;
auto mgd = mgd_iter - > second ; auto mgd = mgd_iter - > second ;
auto super_version = mgd - > super_version ; auto super_version = mgd - > super_version ;
if ( super_version - > mem - > Get ( lkey , value , & s , & merge_context ) ) { bool skip_memtable =
// Done
( read_options . read_tier = = kPersistedTier & & has_unpersisted_data_ ) ;
} else if ( super_version - > imm - > Get ( lkey , value , & s , & merge_context ) ) { bool done = false ;
// Done
if ( ! skip_memtable ) {
} else { if ( super_version - > mem - > Get ( lkey , value , & s , & merge_context ) ) {
done = true ;
// TODO(?): RecordTick(stats_, MEMTABLE_HIT)?
} else if ( super_version - > imm - > Get ( lkey , value , & s , & merge_context ) ) {
done = true ;
// TODO(?): RecordTick(stats_, MEMTABLE_HIT)?
}
}
if ( ! done ) {
PERF_TIMER_GUARD ( get_from_output_files_time ) ; PERF_TIMER_GUARD ( get_from_output_files_time ) ;
super_version - > current - > Get ( read_options , lkey , value , & s , super_version - > current - > Get ( read_options , lkey , value , & s ,
& merge_context ) ; & merge_context ) ;
// TODO(?): RecordTick(stats_, MEMTABLE_MISS)?
} }
if ( s . ok ( ) ) { if ( s . ok ( ) ) {
@ -3424,6 +3515,7 @@ std::vector<Status> DBImpl::MultiGet(
RecordTick ( stats_ , NUMBER_MULTIGET_CALLS ) ; RecordTick ( stats_ , NUMBER_MULTIGET_CALLS ) ;
RecordTick ( stats_ , NUMBER_MULTIGET_KEYS_READ , num_keys ) ; RecordTick ( stats_ , NUMBER_MULTIGET_KEYS_READ , num_keys ) ;
RecordTick ( stats_ , NUMBER_MULTIGET_BYTES_READ , bytes_read ) ; RecordTick ( stats_ , NUMBER_MULTIGET_BYTES_READ , bytes_read ) ;
MeasureTime ( stats_ , BYTES_PER_MULTIGET , bytes_read ) ;
PERF_TIMER_STOP ( get_post_process_time ) ; PERF_TIMER_STOP ( get_post_process_time ) ;
return stat_list ; return stat_list ;
@ -3516,6 +3608,9 @@ Status DBImpl::AddFile(ColumnFamilyHandle* column_family,
auto cfh = reinterpret_cast < ColumnFamilyHandleImpl * > ( column_family ) ; auto cfh = reinterpret_cast < ColumnFamilyHandleImpl * > ( column_family ) ;
ColumnFamilyData * cfd = cfh - > cfd ( ) ; ColumnFamilyData * cfd = cfh - > cfd ( ) ;
if ( file_info - > num_entries = = 0 ) {
return Status : : InvalidArgument ( " File contain no entries " ) ;
}
if ( file_info - > version ! = 1 ) { if ( file_info - > version ! = 1 ) {
return Status : : InvalidArgument ( " Generated table version is not supported " ) ; return Status : : InvalidArgument ( " Generated table version is not supported " ) ;
} }
@ -3536,8 +3631,16 @@ Status DBImpl::AddFile(ColumnFamilyHandle* column_family,
return Status : : InvalidArgument ( return Status : : InvalidArgument (
" Non zero sequence numbers are not supported " ) ; " Non zero sequence numbers are not supported " ) ;
} }
// Generate a location for the new table
// Generate a location for the new table
meta . fd = FileDescriptor ( versions_ - > NewFileNumber ( ) , 0 , file_info - > file_size ) ; std : : list < uint64_t > : : iterator pending_outputs_inserted_elem ;
{
InstrumentedMutexLock l ( & mutex_ ) ;
pending_outputs_inserted_elem = CaptureCurrentFileNumberInPendingOutputs ( ) ;
meta . fd =
FileDescriptor ( versions_ - > NewFileNumber ( ) , 0 , file_info - > file_size ) ;
}
std : : string db_fname = TableFileName ( std : : string db_fname = TableFileName (
db_options_ . db_paths , meta . fd . GetNumber ( ) , meta . fd . GetPathId ( ) ) ; db_options_ . db_paths , meta . fd . GetNumber ( ) , meta . fd . GetPathId ( ) ) ;
@ -3550,6 +3653,7 @@ Status DBImpl::AddFile(ColumnFamilyHandle* column_family,
} else { } else {
status = CopyFile ( env_ , file_info - > file_path , db_fname , 0 ) ; status = CopyFile ( env_ , file_info - > file_path , db_fname , 0 ) ;
} }
TEST_SYNC_POINT ( " DBImpl::AddFile:FileCopied " ) ;
if ( ! status . ok ( ) ) { if ( ! status . ok ( ) ) {
return status ; return status ;
} }
@ -3613,6 +3717,7 @@ Status DBImpl::AddFile(ColumnFamilyHandle* column_family,
delete InstallSuperVersionAndScheduleWork ( cfd , nullptr , delete InstallSuperVersionAndScheduleWork ( cfd , nullptr ,
mutable_cf_options ) ; mutable_cf_options ) ;
} }
ReleaseFileNumberFromPendingOutputs ( pending_outputs_inserted_elem ) ;
} }
if ( ! status . ok ( ) ) { if ( ! status . ok ( ) ) {
@ -3826,6 +3931,10 @@ bool DBImpl::KeyMayExist(const ReadOptions& read_options,
Iterator * DBImpl : : NewIterator ( const ReadOptions & read_options , Iterator * DBImpl : : NewIterator ( const ReadOptions & read_options ,
ColumnFamilyHandle * column_family ) { ColumnFamilyHandle * column_family ) {
if ( read_options . read_tier = = kPersistedTier ) {
return NewErrorIterator ( Status : : NotSupported (
" ReadTier::kPersistedData is not yet supported in iterators. " ) ) ;
}
auto cfh = reinterpret_cast < ColumnFamilyHandleImpl * > ( column_family ) ; auto cfh = reinterpret_cast < ColumnFamilyHandleImpl * > ( column_family ) ;
auto cfd = cfh - > cfd ( ) ; auto cfd = cfh - > cfd ( ) ;
@ -3857,8 +3966,8 @@ Iterator* DBImpl::NewIterator(const ReadOptions& read_options,
env_ , * cfd - > ioptions ( ) , cfd - > user_comparator ( ) , iter , env_ , * cfd - > ioptions ( ) , cfd - > user_comparator ( ) , iter ,
kMaxSequenceNumber , kMaxSequenceNumber ,
sv - > mutable_cf_options . max_sequential_skip_in_iterations , sv - > mutable_cf_options . max_sequential_skip_in_iterations ,
read_options . iterate_upper_bound , read_options . prefix_same_as_start , sv - > version_number , read_options . iterate_upper_bound ,
read_options . pin_data ) ; read_options . prefix_same_as_start , read_options . p in_data ) ;
# endif # endif
} else { } else {
SequenceNumber latest_snapshot = versions_ - > LastSequence ( ) ; SequenceNumber latest_snapshot = versions_ - > LastSequence ( ) ;
@ -3915,8 +4024,8 @@ Iterator* DBImpl::NewIterator(const ReadOptions& read_options,
ArenaWrappedDBIter * db_iter = NewArenaWrappedDbIterator ( ArenaWrappedDBIter * db_iter = NewArenaWrappedDbIterator (
env_ , * cfd - > ioptions ( ) , cfd - > user_comparator ( ) , snapshot , env_ , * cfd - > ioptions ( ) , cfd - > user_comparator ( ) , snapshot ,
sv - > mutable_cf_options . max_sequential_skip_in_iterations , sv - > mutable_cf_options . max_sequential_skip_in_iterations ,
read_options . iterate_upper_bound , read_options . prefix_same_as_start , sv - > version_number , read_options . iterate_upper_bound ,
read_options . pin_data ) ; read_options . prefix_same_as_start , read_options . p in_data ) ;
InternalIterator * internal_iter = InternalIterator * internal_iter =
NewInternalIterator ( read_options , cfd , sv , db_iter - > GetArena ( ) ) ; NewInternalIterator ( read_options , cfd , sv , db_iter - > GetArena ( ) ) ;
@ -3932,6 +4041,10 @@ Status DBImpl::NewIterators(
const ReadOptions & read_options , const ReadOptions & read_options ,
const std : : vector < ColumnFamilyHandle * > & column_families , const std : : vector < ColumnFamilyHandle * > & column_families ,
std : : vector < Iterator * > * iterators ) { std : : vector < Iterator * > * iterators ) {
if ( read_options . read_tier = = kPersistedTier ) {
return Status : : NotSupported (
" ReadTier::kPersistedData is not yet supported in iterators. " ) ;
}
iterators - > clear ( ) ; iterators - > clear ( ) ;
iterators - > reserve ( column_families . size ( ) ) ; iterators - > reserve ( column_families . size ( ) ) ;
XFUNC_TEST ( " " , " managed_new " , managed_new1 , xf_manage_new , XFUNC_TEST ( " " , " managed_new " , managed_new1 , xf_manage_new ,
@ -3965,8 +4078,8 @@ Status DBImpl::NewIterators(
iterators - > push_back ( NewDBIterator ( iterators - > push_back ( NewDBIterator (
env_ , * cfd - > ioptions ( ) , cfd - > user_comparator ( ) , iter , env_ , * cfd - > ioptions ( ) , cfd - > user_comparator ( ) , iter ,
kMaxSequenceNumber , kMaxSequenceNumber ,
sv - > mutable_cf_options . max_sequential_skip_in_iterations , nullptr , sv - > mutable_cf_options . max_sequential_skip_in_iterations ,
false , read_options . pin_data ) ) ; sv - > version_number , nullptr , false , read_options . pin_data ) ) ;
} }
# endif # endif
} else { } else {
@ -3985,8 +4098,8 @@ Status DBImpl::NewIterators(
ArenaWrappedDBIter * db_iter = NewArenaWrappedDbIterator ( ArenaWrappedDBIter * db_iter = NewArenaWrappedDbIterator (
env_ , * cfd - > ioptions ( ) , cfd - > user_comparator ( ) , snapshot , env_ , * cfd - > ioptions ( ) , cfd - > user_comparator ( ) , snapshot ,
sv - > mutable_cf_options . max_sequential_skip_in_iterations , nullptr , sv - > mutable_cf_options . max_sequential_skip_in_iterations ,
false , read_options . pin_data ) ; sv - > version_number , nullptr , false , read_options . pin_data ) ;
InternalIterator * internal_iter = InternalIterator * internal_iter =
NewInternalIterator ( read_options , cfd , sv , db_iter - > GetArena ( ) ) ; NewInternalIterator ( read_options , cfd , sv , db_iter - > GetArena ( ) ) ;
db_iter - > SetIterUnderDBIter ( internal_iter ) ; db_iter - > SetIterUnderDBIter ( internal_iter ) ;
@ -4078,7 +4191,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
} }
Status status ; Status status ;
bool callback_failed = false ;
bool xfunc_attempted_write = false ; bool xfunc_attempted_write = false ;
XFUNC_TEST ( " transaction " , " transaction_xftest_write_impl " , XFUNC_TEST ( " transaction " , " transaction_xftest_write_impl " ,
@ -4096,7 +4208,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
w . sync = write_options . sync ; w . sync = write_options . sync ;
w . disableWAL = write_options . disableWAL ; w . disableWAL = write_options . disableWAL ;
w . in_batch_group = false ; w . in_batch_group = false ;
w . has_ callback= ( callback ! = nullptr ) ? true : false ; w . callback = callback ;
if ( ! write_options . disableWAL ) { if ( ! write_options . disableWAL ) {
RecordTick ( stats_ , WRITE_WITH_WAL ) ; RecordTick ( stats_ , WRITE_WITH_WAL ) ;
@ -4109,28 +4221,32 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
// we are a non-leader in a parallel group
// we are a non-leader in a parallel group
PERF_TIMER_GUARD ( write_memtable_time ) ; PERF_TIMER_GUARD ( write_memtable_time ) ;
ColumnFamilyMemTablesImpl column_family_memtables ( if ( ! w . CallbackFailed ( ) ) {
versions_ - > GetColumnFamilySet ( ) ) ; ColumnFamilyMemTablesImpl column_family_memtables (
WriteBatchInternal : : SetSequence ( w . batch , w . sequence ) ; versions_ - > GetColumnFamilySet ( ) ) ;
w . status = WriteBatchInternal : : InsertInto ( WriteBatchInternal : : SetSequence ( w . batch , w . sequence ) ;
w . batch , & column_family_memtables , & flush_scheduler_ , w . status = WriteBatchInternal : : InsertInto (
write_options . ignore_missing_column_families , 0 /*log_number*/ , this , w . batch , & column_family_memtables , & flush_scheduler_ ,
true /*dont_filter_deletes*/ , true /*concurrent_memtable_writes*/ ) ; write_options . ignore_missing_column_families , 0 /*log_number*/ , this ,
true /*dont_filter_deletes*/ , true /*concurrent_memtable_writes*/ ) ;
}
if ( write_thread_ . CompleteParallelWorker ( & w ) ) { if ( write_thread_ . CompleteParallelWorker ( & w ) ) {
// we're responsible for early exit
// we're responsible for early exit
auto last_sequence = w . parallel_group - > last_writer - > sequence ; auto last_sequence = w . parallel_group - > last_sequence ;
SetTickerCount ( stats_ , SEQUENCE_NUMBER , last_sequence ) ; SetTickerCount ( stats_ , SEQUENCE_NUMBER , last_sequence ) ;
versions_ - > SetLastSequence ( last_sequence ) ; versions_ - > SetLastSequence ( last_sequence ) ;
write_thread_ . EarlyExitParallelGroup ( & w ) ; write_thread_ . EarlyExitParallelGroup ( & w ) ;
} }
assert ( w . state = = WriteThread : : STATE_COMPLETED ) ; assert ( w . state = = WriteThread : : STATE_COMPLETED ) ;
// STATE_COMPLETED conditional below handles exit
// STATE_COMPLETED conditional below handles exit
status = w . FinalStatus ( ) ;
} }
if ( w . state = = WriteThread : : STATE_COMPLETED ) { if ( w . state = = WriteThread : : STATE_COMPLETED ) {
// write is complete and leader has updated sequence
// write is complete and leader has updated sequence
RecordTick ( stats_ , WRITE_DONE_BY_OTHER ) ; RecordTick ( stats_ , WRITE_DONE_BY_OTHER ) ;
return w . status ; return w . FinalStatus ( ) ;
} }
// else we are the leader of the write batch group
// else we are the leader of the write batch group
assert ( w . state = = WriteThread : : STATE_GROUP_LEADER ) ; assert ( w . state = = WriteThread : : STATE_GROUP_LEADER ) ;
@ -4236,7 +4352,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
uint64_t last_sequence = versions_ - > LastSequence ( ) ; uint64_t last_sequence = versions_ - > LastSequence ( ) ;
WriteThread : : Writer * last_writer = & w ; WriteThread : : Writer * last_writer = & w ;
autovector < WriteBatch * > write_batch _group ; autovector < WriteThread : : Writer * > write_group ;
bool need_log_sync = ! write_options . disableWAL & & write_options . sync ; bool need_log_sync = ! write_options . disableWAL & & write_options . sync ;
bool need_log_dir_sync = need_log_sync & & ! log_dir_synced_ ; bool need_log_dir_sync = need_log_sync & & ! log_dir_synced_ ;
@ -4255,24 +4371,15 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
// during this phase since &w is currently responsible for logging
// during this phase since &w is currently responsible for logging
// and protects against concurrent loggers and concurrent writes
// and protects against concurrent loggers and concurrent writes
// into memtables
// into memtables
mutex_ . Unlock ( ) ;
if ( callback ! = nullptr ) {
// If this write has a validation callback, check to see if this write
// is able to be written. Must be called on the write thread.
status = callback - > Callback ( this ) ;
callback_failed = true ;
}
} else {
mutex_ . Unlock ( ) ;
} }
mutex_ . Unlock ( ) ;
// At this point the mutex is unlocked
// At this point the mutex is unlocked
bool exit_completed_early = false ; bool exit_completed_early = false ;
last_batch_group_size_ = write_thread_ . EnterAsBatchGroupLeader ( last_batch_group_size_ =
& w , & last_writer , & write_batch _group ) ; write_thread_ . EnterAsBatchGroupLeader ( & w , & last_writer , & write_group ) ;
if ( status . ok ( ) ) { if ( status . ok ( ) ) {
// Rules for when we can update the memtable concurrently
// Rules for when we can update the memtable concurrently
@ -4288,15 +4395,17 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
// assumed to be true. Rule 4 is checked for each batch. We could
// assumed to be true. Rule 4 is checked for each batch. We could
// relax rules 2 and 3 if we could prevent write batches from referring
// relax rules 2 and 3 if we could prevent write batches from referring
// more than once to a particular key.
// more than once to a particular key.
bool parallel = db_options_ . allow_concurrent_memtable_write & & bool parallel =
write_batch _group . size ( ) > 1 ; db_options_ . allow_concurrent_memtable_write & & write _group. size ( ) > 1 ;
int total_count = 0 ; int total_count = 0 ;
uint64_t total_byte_size = 0 ; uint64_t total_byte_size = 0 ;
for ( auto b : write_batch_group ) { for ( auto writer : write_group ) {
total_count + = WriteBatchInternal : : Count ( b ) ; if ( writer - > CheckCallback ( this ) ) {
total_byte_size = WriteBatchInternal : : AppendedByteSize ( total_count + = WriteBatchInternal : : Count ( writer - > batch ) ;
total_byte_size , WriteBatchInternal : : ByteSize ( b ) ) ; total_byte_size = WriteBatchInternal : : AppendedByteSize (
parallel = parallel & & ! b - > HasMerge ( ) ; total_byte_size , WriteBatchInternal : : ByteSize ( writer - > batch ) ) ;
parallel = parallel & & ! writer - > batch - > HasMerge ( ) ;
}
} }
const SequenceNumber current_sequence = last_sequence + 1 ; const SequenceNumber current_sequence = last_sequence + 1 ;
@ -4305,10 +4414,11 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
// Record statistics
// Record statistics
RecordTick ( stats_ , NUMBER_KEYS_WRITTEN , total_count ) ; RecordTick ( stats_ , NUMBER_KEYS_WRITTEN , total_count ) ;
RecordTick ( stats_ , BYTES_WRITTEN , total_byte_size ) ; RecordTick ( stats_ , BYTES_WRITTEN , total_byte_size ) ;
MeasureTime ( stats_ , BYTES_PER_WRITE , total_byte_size ) ;
PERF_TIMER_STOP ( write_pre_and_post_process_time ) ; PERF_TIMER_STOP ( write_pre_and_post_process_time ) ;
if ( write_options . disableWAL ) { if ( write_options . disableWAL ) {
flush_on_destroy _= true ; has_unpersisted_data _= true ;
} }
uint64_t log_size = 0 ; uint64_t log_size = 0 ;
@ -4316,21 +4426,22 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
PERF_TIMER_GUARD ( write_wal_time ) ; PERF_TIMER_GUARD ( write_wal_time ) ;
WriteBatch * merged_batch = nullptr ; WriteBatch * merged_batch = nullptr ;
if ( write_batch_ group . size ( ) = = 1 ) { if ( write_group . size ( ) = = 1 & & ! write_group [ 0 ] - > CallbackFailed ( ) ) {
merged_batch = write_batch_ group [ 0 ] ; merged_batch = write_group [ 0 ] - > batch ;
} else { } else {
// WAL needs all of the batches flattened into a single batch.
// WAL needs all of the batches flattened into a single batch.
// We could avoid copying here with an iov-like AddRecord
// We could avoid copying here with an iov-like AddRecord
// interface
// interface
merged_batch = & tmp_batch_ ; merged_batch = & tmp_batch_ ;
for ( auto b : write_batch_group ) { for ( auto writer : write_group ) {
WriteBatchInternal : : Append ( merged_batch , b ) ; if ( ! writer - > CallbackFailed ( ) ) {
WriteBatchInternal : : Append ( merged_batch , writer - > batch ) ;
}
} }
} }
WriteBatchInternal : : SetSequence ( merged_batch , current_sequence ) ; WriteBatchInternal : : SetSequence ( merged_batch , current_sequence ) ;
assert ( WriteBatchInternal : : Count ( merged_batch ) = = total_count ) ; assert ( WriteBatchInternal : : Count ( merged_batch ) = = total_count ) ;
assert ( WriteBatchInternal : : ByteSize ( merged_batch ) = = total_byte_size ) ;
Slice log_entry = WriteBatchInternal : : Contents ( merged_batch ) ; Slice log_entry = WriteBatchInternal : : Contents ( merged_batch ) ;
status = logs_ . back ( ) . writer - > AddRecord ( log_entry ) ; status = logs_ . back ( ) . writer - > AddRecord ( log_entry ) ;
@ -4385,7 +4496,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
} }
stats - > AddDBStats ( InternalStats : : WAL_FILE_BYTES , log_size ) ; stats - > AddDBStats ( InternalStats : : WAL_FILE_BYTES , log_size ) ;
} }
uint64_t for_other = write_batch_ group . size ( ) - 1 ; uint64_t for_other = write_group . size ( ) - 1 ;
if ( for_other > 0 ) { if ( for_other > 0 ) {
stats - > AddDBStats ( InternalStats : : WRITE_DONE_BY_OTHER , for_other ) ; stats - > AddDBStats ( InternalStats : : WRITE_DONE_BY_OTHER , for_other ) ;
if ( ! write_options . disableWAL ) { if ( ! write_options . disableWAL ) {
@ -4396,41 +4507,50 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
if ( ! parallel ) { if ( ! parallel ) {
status = WriteBatchInternal : : InsertInto ( status = WriteBatchInternal : : InsertInto (
write_batch_ group , current_sequence , column_family_memtables_ . get ( ) , write_group , current_sequence , column_family_memtables_ . get ( ) ,
& flush_scheduler_ , write_options . ignore_missing_column_families , & flush_scheduler_ , write_options . ignore_missing_column_families ,
0 /*log_number*/ , this , false /*dont_filter_deletes*/ ) ; 0 /*log_number*/ , this , false /*dont_filter_deletes*/ ) ;
if ( status . ok ( ) ) {
// There were no write failures. Set leader's status
// in case the write callback returned a non-ok status.
status = w . FinalStatus ( ) ;
}
} else { } else {
WriteThread : : ParallelGroup pg ; WriteThread : : ParallelGroup pg ;
pg . leader = & w ; pg . leader = & w ;
pg . last_writer = last_writer ; pg . last_writer = last_writer ;
pg . last_sequence = last_sequence ;
pg . early_exit_allowed = ! need_log_sync ; pg . early_exit_allowed = ! need_log_sync ;
pg . running . store ( static_cast < uint32_t > ( write_batch_group . size ( ) ) , pg . running . store ( static_cast < uint32_t > ( write_group . size ( ) ) ,
std : : memory_order_relaxed ) ; std : : memory_order_relaxed ) ;
write_thread_ . LaunchParallelFollowers ( & pg , current_sequence ) ; write_thread_ . LaunchParallelFollowers ( & pg , current_sequence ) ;
ColumnFamilyMemTablesImpl column_family_memtables ( if ( ! w . CallbackFailed ( ) ) {
versions_ - > GetColumnFamilySet ( ) ) ; // do leader write
assert ( w . sequence = = current_sequence ) ; ColumnFamilyMemTablesImpl column_family_memtables (
WriteBatchInternal : : SetSequence ( w . batch , w . sequence ) ; versions_ - > GetColumnFamilySet ( ) ) ;
w . status = WriteBatchInternal : : InsertInto ( assert ( w . sequence = = current_sequence ) ;
w . batch , & column_family_memtables , & flush_scheduler_ , WriteBatchInternal : : SetSequence ( w . batch , w . sequence ) ;
write_options . ignore_missing_column_families , 0 /*log_number*/ , w . status = WriteBatchInternal : : InsertInto (
this , true /*dont_filter_deletes*/ , w . batch , & column_family_memtables , & flush_scheduler_ ,
true /*concurrent_memtable_writes*/ ) ; write_options . ignore_missing_column_families , 0 /*log_number*/ ,
this , true /*dont_filter_deletes*/ ,
assert ( last_writer - > sequence = = last_sequence ) ; true /*concurrent_memtable_writes*/ ) ;
}
// CompleteParallelWorker returns true if this thread should
// CompleteParallelWorker returns true if this thread should
// handle exit, false means somebody else did
// handle exit, false means somebody else did
exit_completed_early = ! write_thread_ . CompleteParallelWorker ( & w ) ; exit_completed_early = ! write_thread_ . CompleteParallelWorker ( & w ) ;
status = w . status ; status = w . FinalStatus ( ) ;
assert ( status . ok ( ) | | ! exit_completed_early ) ;
} }
if ( status . ok ( ) & & ! exit_completed_early ) { if ( ! exit_completed_early & & w . status . ok ( ) ) {
SetTickerCount ( stats_ , SEQUENCE_NUMBER , last_sequence ) ; SetTickerCount ( stats_ , SEQUENCE_NUMBER , last_sequence ) ;
versions_ - > SetLastSequence ( last_sequence ) ; versions_ - > SetLastSequence ( last_sequence ) ;
if ( ! need_log_sync ) { if ( ! need_log_sync ) {
write_thread_ . ExitAsBatchGroupLeader ( & w , last_writer , status ) ; write_thread_ . ExitAsBatchGroupLeader ( & w , last_writer , w . status ) ;
exit_completed_early = true ; exit_completed_early = true ;
} }
} }
@ -4443,14 +4563,14 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
//
//
// Is setting bg_error_ enough here? This will at least stop
// Is setting bg_error_ enough here? This will at least stop
// compaction and fail any further writes.
// compaction and fail any further writes.
if ( ! status . ok ( ) & & bg_error_ . ok ( ) ) { if ( ! status . ok ( ) & & bg_error_ . ok ( ) & & ! w . CallbackFailed ( ) ) {
bg_error_ = status ; bg_error_ = status ;
} }
} }
} }
PERF_TIMER_START ( write_pre_and_post_process_time ) ; PERF_TIMER_START ( write_pre_and_post_process_time ) ;
if ( db_options_ . paranoid_checks & & ! status . ok ( ) & & ! callback_failed & & if ( db_options_ . paranoid_checks & & ! status . ok ( ) & & ! w . CallbackFailed ( ) & &
! status . IsBusy ( ) ) { ! status . IsBusy ( ) ) {
mutex_ . Lock ( ) ; mutex_ . Lock ( ) ;
if ( bg_error_ . ok ( ) ) { if ( bg_error_ . ok ( ) ) {
@ -4466,7 +4586,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
} }
if ( ! exit_completed_early ) { if ( ! exit_completed_early ) {
write_thread_ . ExitAsBatchGroupLeader ( & w , last_writer , status ) ; write_thread_ . ExitAsBatchGroupLeader ( & w , last_writer , w . status ) ;
} }
return status ; return status ;
@ -4678,53 +4798,51 @@ const DBOptions& DBImpl::GetDBOptions() const { return db_options_; }
bool DBImpl : : GetProperty ( ColumnFamilyHandle * column_family , bool DBImpl : : GetProperty ( ColumnFamilyHandle * column_family ,
const Slice & property , std : : string * value ) { const Slice & property , std : : string * value ) {
bool is_int_property = false ; const DBPropertyInfo * property_info = GetPropertyInfo ( property ) ;
bool need_out_of_mutex = false ;
DBPropertyType property_type =
GetPropertyType ( property , & is_int_property , & need_out_of_mutex ) ;
value - > clear ( ) ; value - > clear ( ) ;
auto cfd = reinterpret_cast < ColumnFamilyHandleImpl * > ( column_family ) - > cfd ( ) ; auto cfd = reinterpret_cast < ColumnFamilyHandleImpl * > ( column_family ) - > cfd ( ) ;
if ( is_int_property ) { if ( property_info = = nullptr ) {
return false ;
} else if ( property_info - > handle_int ) {
uint64_t int_value ; uint64_t int_value ;
bool ret_value = GetIntPropertyInternal ( bool ret_value =
cfd , property_type , need_out_of_mutex , false , & int_value ) ; GetIntPropertyInternal ( cfd , * property_info , false , & int_value ) ;
if ( ret_value ) { if ( ret_value ) {
* value = ToString ( int_value ) ; * value = ToString ( int_value ) ;
} }
return ret_value ; return ret_value ;
} else { } else if ( property_info - > handle_string ) {
InstrumentedMutexLock l ( & mutex_ ) ; InstrumentedMutexLock l ( & mutex_ ) ;
return cfd - > internal_stats ( ) - > GetStringProperty ( property_type , property , return cfd - > internal_stats ( ) - > GetStringProperty ( * property_info , property ,
value ) ; value ) ;
} }
// Shouldn't reach here since exactly one of handle_string and handle_int
// should be non-nullptr.
assert ( false ) ;
return false ;
} }
bool DBImpl : : GetIntProperty ( ColumnFamilyHandle * column_family , bool DBImpl : : GetIntProperty ( ColumnFamilyHandle * column_family ,
const Slice & property , uint64_t * value ) { const Slice & property , uint64_t * value ) {
bool is_int_property = false ; const DBPropertyInfo * property_info = GetPropertyInfo ( property ) ;
bool need_out_of_mutex = false ; if ( property_info = = nullptr | | property_info - > handle_int = = nullptr ) {
DBPropertyType property_type =
GetPropertyType ( property , & is_int_property , & need_out_of_mutex ) ;
if ( ! is_int_property ) {
return false ; return false ;
} }
auto cfd = reinterpret_cast < ColumnFamilyHandleImpl * > ( column_family ) - > cfd ( ) ; auto cfd = reinterpret_cast < ColumnFamilyHandleImpl * > ( column_family ) - > cfd ( ) ;
return GetIntPropertyInternal ( cfd , property_type , need_out_of_mutex , false , return GetIntPropertyInternal ( cfd , * property_info , false , value ) ;
value ) ;
} }
bool DBImpl : : GetIntPropertyInternal ( ColumnFamilyData * cfd , bool DBImpl : : GetIntPropertyInternal ( ColumnFamilyData * cfd ,
DBPropertyType property_type , const DBPropertyInfo & property_info ,
bool need_out_of_mutex , bool is_locked , bool is_locked , uint64_t * value ) {
uint64_t * value ) { assert ( property_info . handle_int ! = nullptr ) ;
if ( ! need_out_of_mutex ) { if ( ! property_info . need_out_of_mutex ) {
if ( is_locked ) { if ( is_locked ) {
mutex_ . AssertHeld ( ) ; mutex_ . AssertHeld ( ) ;
return cfd - > internal_stats ( ) - > GetIntProperty ( property_type , value , this ) ; return cfd - > internal_stats ( ) - > GetIntProperty ( property_info , value , this ) ;
} else { } else {
InstrumentedMutexLock l ( & mutex_ ) ; InstrumentedMutexLock l ( & mutex_ ) ;
return cfd - > internal_stats ( ) - > GetIntProperty ( property_type , value , this ) ; return cfd - > internal_stats ( ) - > GetIntProperty ( property_info , value , this ) ;
} }
} else { } else {
SuperVersion * sv = nullptr ; SuperVersion * sv = nullptr ;
@ -4735,7 +4853,7 @@ bool DBImpl::GetIntPropertyInternal(ColumnFamilyData* cfd,
} }
bool ret = cfd - > internal_stats ( ) - > GetIntPropertyOutOfMutex ( bool ret = cfd - > internal_stats ( ) - > GetIntPropertyOutOfMutex (
property_type , sv - > current , value ) ; property_info , sv - > current , value ) ;
if ( ! is_locked ) { if ( ! is_locked ) {
ReturnAndCleanupSuperVersion ( cfd , sv ) ; ReturnAndCleanupSuperVersion ( cfd , sv ) ;
@ -4747,11 +4865,8 @@ bool DBImpl::GetIntPropertyInternal(ColumnFamilyData* cfd,
bool DBImpl : : GetAggregatedIntProperty ( const Slice & property , bool DBImpl : : GetAggregatedIntProperty ( const Slice & property ,
uint64_t * aggregated_value ) { uint64_t * aggregated_value ) {
bool need_out_of_mutex ; const DBPropertyInfo * property_info = GetPropertyInfo ( property ) ;
bool is_int_property ; if ( property_info = = nullptr | | property_info - > handle_int = = nullptr ) {
DBPropertyType property_type =
GetPropertyType ( property , & is_int_property , & need_out_of_mutex ) ;
if ( ! is_int_property ) {
return false ; return false ;
} }
@ -4761,8 +4876,7 @@ bool DBImpl::GetAggregatedIntProperty(const Slice& property,
InstrumentedMutexLock l ( & mutex_ ) ; InstrumentedMutexLock l ( & mutex_ ) ;
uint64_t value ; uint64_t value ;
for ( auto * cfd : * versions_ - > GetColumnFamilySet ( ) ) { for ( auto * cfd : * versions_ - > GetColumnFamilySet ( ) ) {
if ( GetIntPropertyInternal ( cfd , property_type , need_out_of_mutex , true , if ( GetIntPropertyInternal ( cfd , * property_info , true , & value ) ) {
& value ) ) {
sum + = value ; sum + = value ;
} else { } else {
return false ; return false ;
@ -5414,6 +5528,25 @@ Status DB::Open(const DBOptions& db_options, const std::string& dbname,
} }
impl - > mutex_ . Unlock ( ) ; impl - > mutex_ . Unlock ( ) ;
auto sfm = static_cast < SstFileManagerImpl * > (
impl - > db_options_ . sst_file_manager . get ( ) ) ;
if ( s . ok ( ) & & sfm ) {
// Notify SstFileManager about all sst files that already exist in
// db_paths[0] when the DB is opened.
auto & db_path = impl - > db_options_ . db_paths [ 0 ] ;
std : : vector < std : : string > existing_files ;
impl - > db_options_ . env - > GetChildren ( db_path . path , & existing_files ) ;
for ( auto & file_name : existing_files ) {
uint64_t file_number ;
FileType file_type ;
std : : string file_path = db_path . path + " / " + file_name ;
if ( ParseFileName ( file_name , & file_number , & file_type ) & &
file_type = = kTableFile ) {
sfm - > OnAddFile ( file_path ) ;
}
}
}
if ( s . ok ( ) ) { if ( s . ok ( ) ) {
Log ( InfoLogLevel : : INFO_LEVEL , impl - > db_options_ . info_log , " DB pointer %p " , Log ( InfoLogLevel : : INFO_LEVEL , impl - > db_options_ . info_log , " DB pointer %p " ,
impl ) ; impl ) ;
@ -5473,7 +5606,7 @@ Status DestroyDB(const std::string& dbname, const Options& options) {
if ( type = = kMetaDatabase ) { if ( type = = kMetaDatabase ) {
del = DestroyDB ( path_to_delete , options ) ; del = DestroyDB ( path_to_delete , options ) ;
} else if ( type = = kTableFile ) { } else if ( type = = kTableFile ) {
del = DeleteOrMoveToTrash ( & options , path_to_delete ) ; del = DeleteSSTFile ( & options , path_to_delete , 0 ) ;
} else { } else {
del = env - > DeleteFile ( path_to_delete ) ; del = env - > DeleteFile ( path_to_delete ) ;
} }
@ -5489,13 +5622,9 @@ Status DestroyDB(const std::string& dbname, const Options& options) {
for ( size_t i = 0 ; i < filenames . size ( ) ; i + + ) { for ( size_t i = 0 ; i < filenames . size ( ) ; i + + ) {
if ( ParseFileName ( filenames [ i ] , & number , & type ) & & if ( ParseFileName ( filenames [ i ] , & number , & type ) & &
type = = kTableFile ) { // Lock file will be deleted at end
type = = kTableFile ) { // Lock file will be deleted at end
Status del ;
std : : string table_path = db_path . path + " / " + filenames [ i ] ; std : : string table_path = db_path . path + " / " + filenames [ i ] ;
if ( path_id = = 0 ) { Status del = DeleteSSTFile ( & options , table_path ,
del = DeleteOrMoveToTrash ( & options , table_path ) ; static_cast < uint32_t > ( path_id ) ) ;
} else {
del = env - > DeleteFile ( table_path ) ;
}
if ( result . ok ( ) & & ! del . ok ( ) ) { if ( result . ok ( ) & & ! del . ok ( ) ) {
result = del ; result = del ;
} }
@ -5650,7 +5779,8 @@ Status DBImpl::RenameTempFileToOptionsFile(const std::string& file_name) {
void DBImpl : : NewThreadStatusCfInfo ( void DBImpl : : NewThreadStatusCfInfo (
ColumnFamilyData * cfd ) const { ColumnFamilyData * cfd ) const {
if ( db_options_ . enable_thread_tracking ) { if ( db_options_ . enable_thread_tracking ) {
ThreadStatusUtil : : NewColumnFamilyInfo ( this , cfd ) ; ThreadStatusUtil : : NewColumnFamilyInfo ( this , cfd , cfd - > GetName ( ) ,
cfd - > ioptions ( ) - > env ) ;
} }
} }
Praveen Rao
9 years ago