Inside Bitcoin

1001  }
1002
1003  assert(descriptor_file_ == nullptr);
1004  assert(descriptor_log_ == nullptr);
1005  Status r = env_->NewAppendableFile(dscname, &descriptor_file_);
1006  if (!r.ok()) {
1007    Log(options_->info_log, "Reuse MANIFEST: %s\n", r.ToString().c_str());
1008    assert(descriptor_file_ == nullptr);
1009    return false;
1010  }
1011
1012  Log(options_->info_log, "Reusing MANIFEST %s\n", dscname.c_str());
1013  descriptor_log_ = new log::Writer(descriptor_file_, manifest_size);
1014  manifest_file_number_ = manifest_number;
1015  return true;
1016}
1017
1018void VersionSet::MarkFileNumberUsed(uint64_t number) {
1019  if (next_file_number_ <= number) {
1020    next_file_number_ = number + 1;
1021  }
1022}
1023
1024void VersionSet::Finalize(Version* v) {
1025  // Precomputed best level for next compaction
1026  int best_level = -1;
1027  double best_score = -1;
1028
1029  for (int level = 0; level < config::kNumLevels - 1; level++) {
1030    double score;
1031    if (level == 0) {
1032      // We treat level-0 specially by bounding the number of files
1033      // instead of number of bytes for two reasons:
1034      //
1035      // (1) With larger write-buffer sizes, it is nice not to do too
1036      // many level-0 compactions.
1037      //
1038      // (2) The files in level-0 are merged on every read and
1039      // therefore we wish to avoid too many files when the individual
1040      // file size is small (perhaps because of a small write-buffer
1041      // setting, or very high compression ratios, or lots of
1042      // overwrites/deletions).
1043      score = v->files_[level].size() /
1044              static_cast<double>(config::kL0_CompactionTrigger);
1045    } else {
1046      // Compute the ratio of current size to size limit.
1047      const uint64_t level_bytes = TotalFileSize(v->files_[level]);
1048      score =
1049          static_cast<double>(level_bytes) / MaxBytesForLevel(options_, level);
1050    }
1051
1052    if (score > best_score) {
1053      best_level = level;
1054      best_score = score;
1055    }
1056  }
1057
1058  v->compaction_level_ = best_level;
1059  v->compaction_score_ = best_score;
1060}
1061
1062Status VersionSet::WriteSnapshot(log::Writer* log) {
1063  // TODO: Break up into multiple records to reduce memory usage on recovery?
1064
1065  // Save metadata
1066  VersionEdit edit;
1067  edit.SetComparatorName(icmp_.user_comparator()->Name());
1068
1069  // Save compaction pointers
1070  for (int level = 0; level < config::kNumLevels; level++) {
1071    if (!compact_pointer_[level].empty()) {
1072      InternalKey key;
1073      key.DecodeFrom(compact_pointer_[level]);
1074      edit.SetCompactPointer(level, key);
1075    }
1076  }
1077
1078  // Save files
1079  for (int level = 0; level < config::kNumLevels; level++) {
1080    const std::vector<FileMetaData*>& files = current_->files_[level];
1081    for (size_t i = 0; i < files.size(); i++) {
1082      const FileMetaData* f = files[i];
1083      edit.AddFile(level, f->number, f->file_size, f->smallest, f->largest);
1084    }
1085  }
1086
1087  std::string record;
1088  edit.EncodeTo(&record);
1089  return log->AddRecord(record);
1090}
1091
1092int VersionSet::NumLevelFiles(int level) const {
1093  assert(level >= 0);
1094  assert(level < config::kNumLevels);
1095  return current_->files_[level].size();
1096}
1097
1098const char* VersionSet::LevelSummary(LevelSummaryStorage* scratch) const {
1099  // Update code if kNumLevels changes
1100  static_assert(config::kNumLevels == 7, "");
1101  snprintf(scratch->buffer, sizeof(scratch->buffer),
1102           "files[ %d %d %d %d %d %d %d ]", int(current_->files_[0].size()),
1103           int(current_->files_[1].size()), int(current_->files_[2].size()),
1104           int(current_->files_[3].size()), int(current_->files_[4].size()),
1105           int(current_->files_[5].size()), int(current_->files_[6].size()));
1106  return scratch->buffer;
1107}
1108
1109uint64_t VersionSet::ApproximateOffsetOf(Version* v, const InternalKey& ikey) {
1110  uint64_t result = 0;
1111  for (int level = 0; level < config::kNumLevels; level++) {
1112    const std::vector<FileMetaData*>& files = v->files_[level];
1113    for (size_t i = 0; i < files.size(); i++) {
1114      if (icmp_.Compare(files[i]->largest, ikey) <= 0) {
1115        // Entire file is before "ikey", so just add the file size
1116        result += files[i]->file_size;
1117      } else if (icmp_.Compare(files[i]->smallest, ikey) > 0) {
1118        // Entire file is after "ikey", so ignore
1119        if (level > 0) {
1120          // Files other than level 0 are sorted by meta->smallest, so
1121          // no further files in this level will contain data for
1122          // "ikey".
1123          break;
1124        }
1125      } else {
1126        // "ikey" falls in the range for this table.  Add the
1127        // approximate offset of "ikey" within the table.
1128        Table* tableptr;
1129        Iterator* iter = table_cache_->NewIterator(
1130            ReadOptions(), files[i]->number, files[i]->file_size, &tableptr);
1131        if (tableptr != nullptr) {
1132          result += tableptr->ApproximateOffsetOf(ikey.Encode());
1133        }
1134        delete iter;
1135      }
1136    }
1137  }
1138  return result;
1139}
1140
1141void VersionSet::AddLiveFiles(std::set<uint64_t>* live) {
1142  for (Version* v = dummy_versions_.next_; v != &dummy_versions_;
1143       v = v->next_) {
1144    for (int level = 0; level < config::kNumLevels; level++) {
1145      const std::vector<FileMetaData*>& files = v->files_[level];
1146      for (size_t i = 0; i < files.size(); i++) {
1147        live->insert(files[i]->number);
1148      }
1149    }
1150  }
1151}
1152
1153int64_t VersionSet::NumLevelBytes(int level) const {
1154  assert(level >= 0);
1155  assert(level < config::kNumLevels);
1156  return TotalFileSize(current_->files_[level]);
1157}
1158
1159int64_t VersionSet::MaxNextLevelOverlappingBytes() {
1160  int64_t result = 0;
1161  std::vector<FileMetaData*> overlaps;
1162  for (int level = 1; level < config::kNumLevels - 1; level++) {
1163    for (size_t i = 0; i < current_->files_[level].size(); i++) {
1164      const FileMetaData* f = current_->files_[level][i];
1165      current_->GetOverlappingInputs(level + 1, &f->smallest, &f->largest,
1166                                     &overlaps);
1167      const int64_t sum = TotalFileSize(overlaps);
1168      if (sum > result) {
1169        result = sum;
1170      }
1171    }
1172  }
1173  return result;
1174}
1175
1176// Stores the minimal range that covers all entries in inputs in
1177// *smallest, *largest.
1178// REQUIRES: inputs is not empty
1179void VersionSet::GetRange(const std::vector<FileMetaData*>& inputs,
1180                          InternalKey* smallest, InternalKey* largest) {
1181  assert(!inputs.empty());
1182  smallest->Clear();
1183  largest->Clear();
1184  for (size_t i = 0; i < inputs.size(); i++) {
1185    FileMetaData* f = inputs[i];
1186    if (i == 0) {
1187      *smallest = f->smallest;
1188      *largest = f->largest;
1189    } else {
1190      if (icmp_.Compare(f->smallest, *smallest) < 0) {
1191        *smallest = f->smallest;
1192      }
1193      if (icmp_.Compare(f->largest, *largest) > 0) {
1194        *largest = f->largest;
1195      }
1196    }
1197  }
1198}
1199
1200// Stores the minimal range that covers all entries in inputs1 and inputs2
1201// in *smallest, *largest.
1202// REQUIRES: inputs is not empty
1203void VersionSet::GetRange2(const std::vector<FileMetaData*>& inputs1,
1204                           const std::vector<FileMetaData*>& inputs2,
1205                           InternalKey* smallest, InternalKey* largest) {
1206  std::vector<FileMetaData*> all = inputs1;
1207  all.insert(all.end(), inputs2.begin(), inputs2.end());
1208  GetRange(all, smallest, largest);
1209}
1210
1211Iterator* VersionSet::MakeInputIterator(Compaction* c) {
1212  ReadOptions options;
1213  options.verify_checksums = options_->paranoid_checks;
1214  options.fill_cache = false;
1215
1216  // Level-0 files have to be merged together.  For other levels,
1217  // we will make a concatenating iterator per level.
1218  // TODO(opt): use concatenating iterator for level-0 if there is no overlap
1219  const int space = (c->level() == 0 ? c->inputs_[0].size() + 1 : 2);
1220  Iterator** list = new Iterator*[space];
1221  int num = 0;
1222  for (int which = 0; which < 2; which++) {
1223    if (!c->inputs_[which].empty()) {
1224      if (c->level() + which == 0) {
1225        const std::vector<FileMetaData*>& files = c->inputs_[which];
1226        for (size_t i = 0; i < files.size(); i++) {
1227          list[num++] = table_cache_->NewIterator(options, files[i]->number,
1228                                                  files[i]->file_size);
1229        }
1230      } else {
1231        // Create concatenating iterator for the files from this level
1232        list[num++] = NewTwoLevelIterator(
1233            new Version::LevelFileNumIterator(icmp_, &c->inputs_[which]),
1234            &GetFileIterator, table_cache_, options);
1235      }
1236    }
1237  }
1238  assert(num <= space);
1239  Iterator* result = NewMergingIterator(&icmp_, list, num);
1240  delete[] list;
1241  return result;
1242}
1243
1244Compaction* VersionSet::PickCompaction() {
1245  Compaction* c;
1246  int level;
1247
1248  // We prefer compactions triggered by too much data in a level over
1249  // the compactions triggered by seeks.
1250  const bool size_compaction = (current_->compaction_score_ >= 1);