name stringlengths 1 4.98k | code stringlengths 61 2.07M | asm stringlengths 57 12.9M | file stringlengths 18 192 |
|---|---|---|---|
hlkvds::DS_MultiTier_Impl::GetKeyByHashEntry[abi:cxx11](hlkvds::HashEntry*) | std::string DS_MultiTier_Impl::GetKeyByHashEntry(HashEntry *entry) {
TierType tier_type = locateTierFromEntry(entry);
if (tier_type == TierType::FastTierType) {
return ft_->GetKeyByHashEntry(entry);
}
return mt_->GetKeyByHashEntry(entry);
} | subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x20(%rsp), %rsi
callq 0x10c30
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x11417
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::GetValueByHashEntry[abi:cxx11](hlkvds::HashEntry*) | std::string DS_MultiTier_Impl::GetValueByHashEntry(HashEntry *entry) {
//TODO: find location
TierType tier_type = locateTierFromEntry(entry);
if (tier_type == TierType::FastTierType) {
return ft_->GetValueByHashEntry(entry);
}
return mt_->GetValueByHashEntry(entry);
} | subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x20(%rsp), %rsi
callq 0x10c30
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x11497
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::CalcSSTsLengthOnDiskBySegNum(unsigned int) | uint64_t DS_MultiTier_Impl::CalcSSTsLengthOnDiskBySegNum(uint32_t seg_num) {
uint64_t sst_pure_length = sizeof(SegmentStat) * seg_num;
uint64_t sst_length = sst_pure_length + sizeof(time_t);
uint64_t sst_pages = sst_length / getpagesize();
sst_length = (sst_pages + 1) * getpagesize();
return sst_len... | subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl 0x34(%rsp), %eax
imulq $0xc, %rax, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x8860
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movq %rax, 0x18(%... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::CalcSegNumForFastTierVolume(unsigned long, unsigned long, unsigned int, unsigned int) | uint32_t DS_MultiTier_Impl::CalcSegNumForFastTierVolume(uint64_t capacity, uint64_t sst_offset, uint32_t fast_tier_seg_size, uint32_t med_tier_seg_num) {
uint64_t valid_capacity = capacity - sst_offset;
uint32_t seg_num_candidate = valid_capacity / fast_tier_seg_size;
uint32_t seg_num_total = seg_num_candi... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
xorl %edx, %edx
divq %rcx
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl 0x20(%rsp), %e... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiVolume_Impl::deleteAllSegments() | void DS_MultiVolume_Impl::deleteAllSegments() {
std::unique_lock<std::mutex> lck_seg_map(segMapMtx_);
for (int i = 0; i< shardsNum_; i++) {
SegForReq* seg = segMap_[i];
delete seg;
std::mutex *seg_mtx = segMtxVec_[i];
delete seg_mtx;
}
segMap_.clear();
segMtxVec_.clea... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rsi
movq %rsi, 0x20(%rsp)
addq $0x60, %rsi
leaq 0x50(%rsp), %rdi
callq 0x15a10
movl $0x0, 0x4c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x4c(%rsp), %eax
cmpl 0x58(%rcx), %eax
jge 0x11c3d
movq 0x20(%rsp), %rdi
addq $0x88, %rdi
leaq 0x4c(%rsp), %rsi
callq 0x16c10
movq %rax... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::deleteAllVolumes() | void DS_MultiVolume_Impl::deleteAllVolumes() {
map<int, Volume *>::iterator iter;
for (iter = volMap_.begin(); iter != volMap_.end(); ) {
Volume *vol = iter->second;
delete vol;
volMap_.erase(iter++);
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x16ad0
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0x16af0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0x16b40
movq %rax, 0x38(%rsp)
leaq 0x... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::InitSegmentBuffer() | void DS_MultiVolume_Impl::InitSegmentBuffer() {
std::unique_lock<std::mutex> lck_seg_map(segMapMtx_);
for (int i = 0; i < shardsNum_; i++) {
int vol_id = pickVol();
SegForReq * seg = new SegForReq(volMap_[vol_id], idxMgr_, options_.expired_time);
segMap_.insert(make_pair(i, seg));
... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rsi
movq %rsi, 0x50(%rsp)
addq $0x60, %rsi
leaq 0xa0(%rsp), %rdi
callq 0x15a10
movl $0x0, 0x9c(%rsp)
movq 0x50(%rsp), %rcx
movl 0x9c(%rsp), %eax
cmpl 0x58(%rcx), %eax
jge 0x11f62
movq 0x50(%rsp), %rdi
callq 0x11fa0
movl %eax, 0x4c(%rsp)
jmp 0x11ded
movl 0x4c(%rsp... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::pickVol() | int DS_MultiVolume_Impl::pickVol() {
std::lock_guard <std::mutex> l(volIdMtx_);
if ( pickVolId_ == (int)(volNum_ - 1) ){
pickVolId_ = 0;
}
else {
pickVolId_++;
}
return pickVolId_;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, 0x10(%rsp)
addq $0xf8, %rsi
leaq 0x18(%rsp), %rdi
callq 0xb5f0
movq 0x10(%rsp), %rcx
movl 0xf0(%rcx), %eax
movl 0xe0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x11fed
movq 0x10(%rsp), %rax
movl $0x0, 0xf0(%rax)
jmp 0x12001
movq 0x10(%rsp), %r... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::StartThds() | void DS_MultiVolume_Impl::StartThds() {
for (int i = 0; i < shardsNum_; i++) {
ReqsMergeWQ *req_wq = new ReqsMergeWQ(this, 1);
req_wq->Start();
reqWQVec_.push_back(req_wq);
}
segWteWQ_ = new SegmentWriteWQ(this, options_.seg_write_thread);
segWteWQ_->Start();
segTimeoutT_st... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x5c(%rsp), %eax
cmpl 0x58(%rcx), %eax
jge 0x120d3
movl $0xd8, %edi
callq 0x84f0
movq 0x10(%rsp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0x1, %edx
callq 0x15c70
jm... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::SegTimeoutThdEntry() | void DS_MultiVolume_Impl::SegTimeoutThdEntry() {
__DEBUG("Segment Timeout thread start!!");
std::unique_lock<std::mutex> lck_seg_map(segMapMtx_, std::defer_lock);
while (!segTimeoutT_stop_) {
for ( int i = 0; i < shardsNum_; i++) {
std::mutex *mtx = segMtxVec_[i];
std::uniqu... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq 0xf0(%rsp), %rsi
movq %rsi, 0x60(%rsp)
addq $0x60, %rsi
leaq 0xe0(%rsp), %rdi
callq 0x16db0
movq 0x60(%rsp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x16f80
xorb $-0x1, %al
testb $0x1, %al
jne 0x12249
jmp 0x1254a
movl $0x0, 0xd8(%rsp)
movq 0x60(%rsp), %rcx
movl ... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::StopThds() | void DS_MultiVolume_Impl::StopThds() {
for (uint32_t i = 0; i < volNum_; i++) {
volMap_[i]->StopThds();
}
segTimeoutT_stop_.store(true);
segTimeoutT_.join();
for (int i = 0; i < shardsNum_; i++) {
ReqsMergeWQ *req_wq = reqWQVec_[i];
req_wq->Stop();
delete req_wq;
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0xe0(%rcx), %eax
jae 0x125dc
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x160f0
movq (%rax), %rdi
... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::printDeviceTopologyInfo() | void DS_MultiVolume_Impl::printDeviceTopologyInfo() {
__INFO("\nDB Device Topology information:\n"
"\t Segment size : %d\n"
"\t Volumes number : %d",
sbResHeader_.segment_size, sbResHeader_.volume_num);
for (uint32_t i = 0 ; i < sbResHeader_.volume... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x5e8ee(%rip), %rax # 0x70fd8
movq (%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x8480
movq 0x28(%rsp), %rdi
movq %rax, %rdx
leaq 0x3fcb6(%rip), %rsi # 0x523bc
leaq 0x3fccf(%rip), %rcx # 0x523dc
leaq 0x3fe3d(%rip), %r8 ... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::getReqQueSize() | uint32_t DS_MultiVolume_Impl::getReqQueSize() {
if (reqWQVec_.empty()) {
return 0;
}
int reqs_num = 0;
for (int i = 0; i< shardsNum_; i++) {
ReqsMergeWQ *req_wq = reqWQVec_[i];
reqs_num += req_wq->Size();
}
return reqs_num;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x140, %rdi # imm = 0x140
callq 0x16920
testb $0x1, %al
jne 0x12954
jmp 0x1295e
movl $0x0, 0x24(%rsp)
jmp 0x129bf
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movq (%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x58(%rcx), %eax
jge ... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::WriteData(hlkvds::KVSlice&, bool) | Status DS_MultiVolume_Impl::WriteData(KVSlice& slice, bool immediately) {
if (slice.GetDataLen() > maxValueLen_) {
return Status::NotSupported("Data length cann't be longer than max segment size");
}
if (options_.aggregate_request == 1 && !immediately) {
return writeDataAggregate(slice);
... | subq $0x38, %rsp
movq %rdi, (%rsp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x163a0
movq 0x10(%rsp), %rcx
movzwl %ax, %eax
cmpl 0xdc(%rc... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::writeDataAggregate(hlkvds::KVSlice&) | Status DS_MultiVolume_Impl::writeDataAggregate(KVSlice& slice) {
Request *req = new Request(slice);
int shards_id = calcShardId(slice);
req->SetShardsWQId(shards_id);
ReqsMergeWQ *req_wq = reqWQVec_[shards_id];
req_wq->Add_task(req);
req->Wait();
Status s = updateMeta(req);
delete req... | subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x78, %edi
callq 0x84f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rsi
callq 0x41540
jmp 0x12b1b
mo... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::writeDataImmediately(hlkvds::KVSlice&) | Status DS_MultiVolume_Impl::writeDataImmediately(KVSlice& slice) {
uint32_t seg_id = 0;
bool ret = false;
int vol_id = pickVol();
Volume *vol = volMap_[vol_id];
//TODO: use GcSegment first, need abstract segment.
while (!vol->Alloc(seg_id)) {
ret = vol->ForeGC();
if (!ret) {
... | subq $0x88, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movl $0x0, 0x6c(%rsp)
movb $0x0, 0x6b(%rsp)
callq 0x11fa0
movq 0x38(%rsp), %rdi
movl %eax, 0x64(%rsp)
addq $0x28, %rdi
leaq 0x64(%rsp... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::WriteBatchData(hlkvds::WriteBatch*) | Status DS_MultiVolume_Impl::WriteBatchData(WriteBatch *batch) {
uint32_t seg_id = 0;
bool ret;
int vol_id = pickVol();
Volume *vol = volMap_[vol_id];
//TODO: use GcSegment first, need abstract segment.
while (!vol->Alloc(seg_id)) {
ret = vol->ForeGC();
if (!ret) {
_... | subq $0xc8, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x58(%rsp)
movl $0x0, 0xac(%rsp)
callq 0x11fa0
movq 0x58(%rsp), %rdi
movl %eax, 0xa4(%rsp)
addq $0x28, %rdi
leaq 0xa4(%rsp), %rsi
callq 0x15a50
... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::ReadData(hlkvds::KVSlice&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | Status DS_MultiVolume_Impl::ReadData(KVSlice &slice, string &data) {
HashEntry *entry;
entry = &slice.GetHashEntry();
int vol_id = getVolIdFromEntry(entry);
Volume *vol = volMap_[vol_id];
uint64_t data_offset = 0;
if (!vol->CalcDataOffsetPhyFromEntry(entry, data_offset)) {
return Statu... | subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
callq 0x116b0
movq 0x30(%rsp), %rdi
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rsi
callq 0x1... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::GetSBReservedContent(char*, unsigned long) | bool DS_MultiVolume_Impl::GetSBReservedContent(char* buf, uint64_t length) {
if (length != SuperBlockManager::ReservedRegionLength()) {
return false;
}
memset((void*)buf, 0, length);
//Get sbResHeader_
uint64_t header_size = sizeof(MultiVolumeDS_SB_Reserved_Header);
memcpy((void*)buf, (... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x116c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
je 0x13673
movb $0x0, 0x67(%rsp)
jmp 0x1373a
movq 0x50(%rsp), %rdi
movq 0x48(%rsp... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::SetSBReservedContent(char*, unsigned long) | bool DS_MultiVolume_Impl::SetSBReservedContent(char* buf, uint64_t length) {
if (length != SuperBlockManager::ReservedRegionLength()) {
return false;
}
//Set sbResHeader_
uint64_t header_size = sizeof(MultiVolumeDS_SB_Reserved_Header);
memcpy((void*)&sbResHeader_, (const void*)buf, header_s... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x158(%rsp)
movq %rsi, 0x150(%rsp)
movq %rdx, 0x148(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x116c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x13838
movb $0x0, 0x167(%rsp)
jmp 0x13923
movq ... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::GetAllSSTs(char*, unsigned long) | bool DS_MultiVolume_Impl::GetAllSSTs(char* buf, uint64_t length) {
uint64_t sst_total_length = GetSSTsLengthOnDisk();
if (length != sst_total_length) {
return false;
}
char *buf_ptr = buf;
//Copy TS
int64_t time_len = KVTime::SizeOf();
lastTime_->Update();
time_t t = lastTime_->... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
callq *0x98(%rax)
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x13981
movb $0x0, 0x67(%rsp)
jmp 0x13a87
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
cal... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::SetAllSSTs(char*, unsigned long) | bool DS_MultiVolume_Impl::SetAllSSTs(char* buf, uint64_t length) {
uint64_t sst_total_length = GetSSTsLengthOnDisk();
if (length != sst_total_length) {
return false;
}
char *buf_ptr = buf;
//Set TS
int64_t time_len = KVTime::SizeOf();
time_t t;
memcpy((void *)&t, (const void *)b... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
callq *0x98(%rax)
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x13ae1
movb $0x0, 0x67(%rsp)
jmp 0x13bd3
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
cal... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::CreateAllComponents(unsigned long) | bool DS_MultiVolume_Impl::CreateAllComponents(uint64_t sst_offset) {
segSize_ = options_.segment_size;
uint32_t align_bit = log2(ALIGNED_SIZE);
if (segSize_ != (segSize_ >> align_bit) << align_bit) {
__ERROR("Segment Size is not page aligned!");
return false;
}
maxValueLen_ = segSi... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x118(%rsp)
movq %rsi, 0x110(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x8(%rax), %rcx
movl 0x44(%rcx), %ecx
movl %ecx, 0xd8(%rax)
movl $0x1000, %edi # imm = 0x1000
callq 0x16680
movq 0x60(%rsp), %rcx
cvttsd2si %xmm0, %rax
movl %eax, 0x10c(%r... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::calcSegNumForMetaVolume(unsigned long, unsigned long, unsigned int, unsigned int) | uint32_t DS_MultiVolume_Impl::calcSegNumForMetaVolume(uint64_t capacity, uint64_t sst_offset, uint32_t total_buddy_seg_num, uint32_t seg_size) {
uint64_t valid_capacity = capacity - sst_offset;
uint32_t seg_num_candidate = valid_capacity / seg_size;
uint32_t seg_num_total = seg_num_candidate + total_buddy_... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movl %r8d, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x28(%rsp), %ecx
xorl %edx, %edx
divq %rcx
m... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::initSBReservedContentForCreate() | void DS_MultiVolume_Impl::initSBReservedContentForCreate() {
sbResHeader_.segment_size = segSize_;
sbResHeader_.volume_num = volNum_;
for(uint32_t i = 0; i < volNum_; i++)
{
MultiVolumeDS_SB_Reserved_Volume sb_res_vol;
string dev_path = volMap_[i]->GetDevicePath();
memcpy((void... | subq $0x198, %rsp # imm = 0x198
movq %rdi, 0x190(%rsp)
movq 0x190(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0xd8(%rax), %ecx
movl %ecx, 0x120(%rax)
movl 0xe0(%rax), %ecx
movl %ecx, 0x124(%rax)
movl $0x0, 0x18c(%rsp)
movq 0x40(%rsp), %rcx
movl 0x18c(%rsp), %eax
cmpl 0xe0(%rcx), %eax
jae 0x14390
leaq 0x84(%rsp), ... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::OpenAllComponents() | bool DS_MultiVolume_Impl::OpenAllComponents() {
volNum_ = sbResHeader_.volume_num;
segSize_ = sbResHeader_.segment_size;
maxValueLen_ = segSize_ - SegBase::SizeOfSegOnDisk() - IndexManager::SizeOfHashEntryOnDisk();
sstLengthOnDisk_ = sbMgr_->GetSSTRegionLength();
BlockDevice *meta_bdev = bdVec_[0];... | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0xf8(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x58(%rsp)
movl 0x124(%rax), %ecx
movl %ecx, 0xe0(%rax)
movl 0x120(%rax), %ecx
movl %ecx, 0xd8(%rax)
movl 0xd8(%rax), %eax
movq %rax, 0x48(%rsp)
callq 0x166a0
movq %rax, %rcx
movq 0x48(%rsp), %rax
subq %rcx, %rax
movq %rax... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::verifyTopology() | bool DS_MultiVolume_Impl::verifyTopology() {
if (volNum_ != bdVec_.size()) {
return false;
}
for (uint32_t i = 0; i < volNum_; i++) {
string record_path = string(sbResVolVec_[i].dev_path);
string device_path = bdVec_[i]->GetDevicePath();
if (record_path != device_path) {
... | subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0xe0(%rax), %ecx
movq %rcx, 0x38(%rsp)
movq 0x10(%rax), %rdi
callq 0x166c0
movq %rax, %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
je 0x1485a
movb $0x0, 0xb7(%rsp)
jmp 0x14a47
movl $0x0, 0xa4(%rsp)
movq 0x30(%rsp), %rcx
movl 0xa4(%rsp... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::GetKeyByHashEntry[abi:cxx11](hlkvds::HashEntry*) | string DS_MultiVolume_Impl::GetKeyByHashEntry(HashEntry *entry) {
uint64_t key_offset = 0;
int vol_id = getVolIdFromEntry(entry);
Volume *vol = volMap_[vol_id];
if (!vol->CalcKeyOffsetPhyFromEntry(entry, key_offset)) {
return "";
}
__DEBUG("key offset: %lu",key_offset);
uint16_t ke... | subq $0xb8, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
movq %rdi, 0x58(%rsp)
movq $0x0, 0x98(%rsp)
movq 0xa0(%rsp), %rsi
callq 0x13530
movq 0x58(%rsp), %rdi
movl %eax, 0x94(%rsp)
addq $0x28, %rdi
leaq 0x94(%rsp... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::GetValueByHashEntry[abi:cxx11](hlkvds::HashEntry*) | string DS_MultiVolume_Impl::GetValueByHashEntry(HashEntry *entry) {
uint64_t data_offset = 0;
int vol_id = getVolIdFromEntry(entry);
Volume *vol = volMap_[vol_id];
if (!vol->CalcDataOffsetPhyFromEntry(entry, data_offset)) {
return "";
}
__DEBUG("data offset: %lu",data_offset);
uint... | subq $0xb8, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
movq %rdi, 0x58(%rsp)
movq $0x0, 0x98(%rsp)
movq 0xa0(%rsp), %rsi
callq 0x13530
movq 0x58(%rsp), %rdi
movl %eax, 0x94(%rsp)
addq $0x28, %rdi
leaq 0x94(%rsp... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::updateMeta(hlkvds::Request*) | Status DS_MultiVolume_Impl::updateMeta(Request *req) {
bool res = req->GetWriteStat();
// update index
if (!res) {
return Status::Aborted("Write failed");
}
KVSlice *slice = &req->GetSlice();
res = idxMgr_->UpdateIndex(slice);
// minus the segment delete counter
SegForReq *seg = ... | subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x16a70
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x151a2
movq (%rsp), %rdi
leaq 0x3d710(... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::getTotalFreeSegs() | uint32_t DS_MultiVolume_Impl::getTotalFreeSegs() {
uint32_t free_num = 0;
for (uint32_t i = 0; i < volNum_; i++) {
free_num += volMap_[i]->GetTotalFreeSegs();
}
return free_num;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0xe0(%rcx), %eax
jae 0x1528c
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x160f0... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::ReqMerge(hlkvds::Request*) | void DS_MultiVolume_Impl::ReqMerge(Request* req) {
int shard_id = req->GetShardsWQId();
std::unique_lock<std::mutex> lck_seg_map(segMapMtx_, std::defer_lock);
std::mutex *seg_mtx = segMtxVec_[shard_id];
std::unique_lock<std::mutex> lck_seg(*seg_mtx);
lck_seg_map.lock();
SegForReq *seg = segMa... | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xf8(%rsp), %rdi
callq 0x16da0
movq 0x60(%rsp), %rsi
movl %eax, 0xf4(%rsp)
addq $0x60, %rsi
leaq 0xe0(%rsp), %rdi
callq 0x16db0
movq 0x60(%rsp), %rdi
addq $0xb8, %rdi
movslq 0xf4(%rs... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
hlkvds::DS_MultiVolume_Impl::SegWrite(hlkvds::SegForReq*) | void DS_MultiVolume_Impl::SegWrite(SegForReq *seg) {
Volume *vol = seg->GetSelfVolume();
uint32_t seg_id = 0;
bool res;
while (!vol->Alloc(seg_id)) {
res = vol->ForeGC();
if (!res) {
__ERROR("Cann't get a new Empty Segment.\n");
seg->Notify(res);
}
}... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x16f70
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x50e40
xorb $-0x1, %al
testb $0x1, %al
jne 0x1564f
jmp 0x156f2
movq 0x20(%rsp), %rdi
callq 0x51250
andb $0x1, %al
movb %al, 0x1b... | yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc |
dslab::WorkQueue<hlkvds::Request>::Stop() | void Stop() {
stop_.store(true);
cv_.notify_all();
for (auto &t : threads_) {
t.join();
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0xcc, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x15f20
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x87e0
movq 0x8(%rsp), %rax
addq $0xb0, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1c0a0
movq %rax, 0x20(%rsp)
movq 0... | yangwanyuan[P]HLKVDS/./src/include/WorkQueue.h |
dslab::WorkQueue<hlkvds::Request>::worker() | void worker()
{
while(1) {
std::unique_lock<std::mutex> lck(mtx_, std::defer_lock);
lck.lock();
cv_.wait_for(lck, std::chrono::milliseconds(1000), [this] {return !dataQueue_.empty();});
if (this->stop_.load() && this->dataQueue_.empty()) {
lck... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
addq $0x58, %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x16db0
movq 0x20(%rsp), %rdi
callq 0x16dd0
jmp 0x1ba40
movq 0x28(%rsp), %rax
subq $-0x80, %rax
movq %rax, 0x18(%rsp)
movl $0x3e8, 0x4c(%rsp) #... | yangwanyuan[P]HLKVDS/./src/include/WorkQueue.h |
hlkvds::DataStor::Create(hlkvds::Options&, std::vector<hlkvds::BlockDevice*, std::allocator<hlkvds::BlockDevice*>>&, hlkvds::SuperBlockManager*, hlkvds::IndexManager*, int) | DataStor* DataStor::Create(Options &opts, std::vector<BlockDevice*> &dev_vec, SuperBlockManager* sb, IndexManager* idx, int datastor_type) {
switch (datastor_type) {
case 0:
return new DS_MultiVolume_Impl(opts, dev_vec, sb, idx);
case 1:
return new DS_MultiTier_Impl(opts, de... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x18(%rsp)
testl %eax, %eax
je 0x21b69
jmp 0x21b5b
movl 0x18(%rsp), %eax
subl $0x1, %eax
je 0x21bc5
jmp 0x21c21
movl $0x170, %edi # imm = 0x170
callq... | yangwanyuan[P]HLKVDS/src/DataStor.cc |
hlkvds::GcManager::GcManager(hlkvds::IndexManager*, hlkvds::Volume*, hlkvds::Options&) | GcManager::GcManager(IndexManager* im, Volume* vol, Options &opt) :
options_(opt), dataBuf_(NULL) {
idxMgr_ = im;
vol_ = vol;
uint32_t seg_size = vol_->GetSegmentSize();
posix_memalign((void **)&dataBuf_, 4096, seg_size);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
callq 0x15800
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%... | yangwanyuan[P]HLKVDS/src/GcManager.cc |
hlkvds::GcManager::ForeGC() | bool GcManager::ForeGC() {
std::lock_guard < std::mutex > lck_gc(gcMtx_);
//check free segment;
uint32_t free_seg_num = vol_->GetTotalFreeSegs();
if (free_seg_num > SEG_RESERVED_FOR_GC) {
__DEBUG("some thread already called doForeGC, ignore this call!");
return true;
}
free_seg_... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rsi
movq %rsi, 0x18(%rsp)
addq $0x18, %rsi
leaq 0x70(%rsp), %rdi
callq 0xb5f0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x510f0
movl %eax, 0x24(%rsp)
jmp 0x21d97
movl 0x24(%rsp), %eax
movl %eax, 0x6c(%rsp)
cmpl $0x2, 0x6c(%rsp)
jbe 0x21dce
movb $0x1, 0x87(%rs... | yangwanyuan[P]HLKVDS/src/GcManager.cc |
hlkvds::GcManager::doMerge(std::multimap<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>&) | uint32_t GcManager::doMerge(std::multimap<uint32_t, uint32_t> &cands_map) {
bool ret;
std::vector < uint32_t > free_seg_vec;
uint32_t last_seg_id = 0;
bool need_flag = false;
uint32_t total_free = 0;
std::list<KVSlice*> slice_list;
std::list<KVSlice*> recycle_list;
std::list<KVSlice*>... | subq $0x198, %rsp # imm = 0x198
movq %rdi, 0x188(%rsp)
movq %rsi, 0x180(%rsp)
movq 0x188(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x160(%rsp), %rdi
callq 0x23510
movl $0x0, 0x15c(%rsp)
movb $0x0, 0x15b(%rsp)
movl $0x0, 0x154(%rsp)
leaq 0x138(%rsp), %rdi
callq 0x23520
leaq 0x120(%rsp), %rdi
callq 0x23520
leaq 0... | yangwanyuan[P]HLKVDS/src/GcManager.cc |
hlkvds::GcManager::BackGC() | void GcManager::BackGC() {
std::unique_lock < std::mutex > lck_gc(gcMtx_, std::defer_lock);
uint32_t seg_size = vol_->GetSegmentSize();
uint64_t data_theory_size = idxMgr_->GetDataTheorySize();
uint32_t theory_seg_num = data_theory_size / seg_size + 1;
uint32_t free_seg_num = vol_->GetTotalFreeSeg... | subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq 0xd0(%rsp), %rsi
movq %rsi, 0x40(%rsp)
addq $0x18, %rsi
leaq 0xc0(%rsp), %rdi
callq 0x16db0
movq 0x40(%rsp), %rax
movq (%rax), %rdi
callq 0x234a0
movl %eax, 0x48(%rsp)
jmp 0x227f0
movq 0x40(%rsp), %rax
movl 0x48(%rsp), %ecx
movl %ecx, 0xb8(%rsp)
movq 0x8(%rax), %rdi
callq 0x2... | yangwanyuan[P]HLKVDS/src/GcManager.cc |
hlkvds::GcManager::FullGC() | void GcManager::FullGC() {
std::unique_lock < std::mutex > lck_gc(gcMtx_, std::defer_lock);
__DEBUG("Begin do Full GC!");
uint32_t free_before = vol_->GetTotalFreeSegs();
uint32_t free_after = 0;
uint32_t used_total = 0;
uint32_t seg_num = vol_->GetNumberOfSeg();
uint32_t total_free = 0;
... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rsi
movq %rsi, 0x30(%rsp)
addq $0x18, %rsi
leaq 0xb0(%rsp), %rdi
callq 0x16db0
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x510f0
movl %eax, 0x38(%rsp)
jmp 0x22ba0
movq 0x30(%rsp), %rax
movl 0x38(%rsp), %ecx
movl %ecx, 0xa8(%rsp)
movl $0x0, 0x98(%rsp)
movl $0x... | yangwanyuan[P]HLKVDS/src/GcManager.cc |
hlkvds::GcManager::loadKvList(unsigned int, std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&) | bool GcManager::loadKvList(uint32_t seg_id, std::list<KVSlice*> &slice_list) {
uint64_t seg_phy_off;
vol_->CalcSegOffsetFromId(seg_id, seg_phy_off);
uint32_t seg_size = vol_->GetSegmentSize();
if (!vol_->Read(dataBuf_, seg_size, seg_phy_off)) {
return false;
}
SegHeaderOnDisk seg_heade... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rdi
movl 0x64(%rsp), %esi
leaq 0x50(%rsp), %rdx
callq 0x23960
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x234a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4c(%rsp)
mov... | yangwanyuan[P]HLKVDS/src/GcManager.cc |
hlkvds::GcManager::cleanKvList(std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&) | void GcManager::cleanKvList(std::list<KVSlice*> &slice_list) {
while (!slice_list.empty()) {
KVSlice *slice = slice_list.front();
slice_list.pop_front();
const char* key = slice->GetKey();
delete[] key;
const char* data = slice->GetData();
delete[] data;
delet... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x239b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x22f23
jmp 0x22fba
movq 0x38(%rsp), %rdi
callq 0x239d0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x23a00
movq 0x30(%rsp), %rdi
callq 0x23a30
movq %rax, 0x28(%rs... | yangwanyuan[P]HLKVDS/src/GcManager.cc |
hlkvds::GcManager::loadSegKV(std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&, unsigned int, unsigned long) | void GcManager::loadSegKV(list<KVSlice*> &slice_list, uint32_t num_keys,
uint64_t phy_offset) {
uint32_t head_offset = SegBase::SizeOfSegOnDisk();
int vol_id = vol_->GetId();
for (uint32_t index = 0; index < num_keys; index++) {
DataHeader header;
memcpy(&header, &... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movl %edx, 0x104(%rsp)
movq %rcx, 0xf8(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x48(%rsp)
callq 0x166a0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movl %ecx, 0xf4(%rsp)
movq (%rax), %rdi
callq 0x238c0
movl %eax, 0xf0(%rsp)
movl $0x0, 0x... | yangwanyuan[P]HLKVDS/src/GcManager.cc |
hlkvds::Volume::CalcSegOffsetFromId(unsigned int, unsigned long&) | inline bool CalcSegOffsetFromId(uint32_t seg_id, uint64_t& offset) {
if (seg_id >= segNum_) {
return false;
}
offset = ((uint64_t) seg_id << segSizeBit_);
return true;
} | movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x28(%rsp)
movl -0x14(%rsp), %eax
cmpl 0x3c(%rcx), %eax
jb 0x23988
movb $0x0, -0x1(%rsp)
jmp 0x239a7
movq -0x28(%rsp), %rcx
movl -0x14(%rsp), %eax
movl 0x40(%rcx), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x20(%rsp)... | yangwanyuan[P]HLKVDS/./src/include/Volume.h |
hlkvds::HashEntry::~HashEntry() | HashEntry::~HashEntry() {
cachePtr_ = NULL;
if (entryPtr_) {
delete entryPtr_;
}
if (stampPtr_) {
delete stampPtr_;
}
return;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rax)
cmpq $0x0, (%rax)
je 0x253fa
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x253f8
movq 0x10(%rsp), %rdi
callq 0x24fa0
movq 0x10(%rsp), %rdi
callq 0x84b0
jmp 0x253fa
movq 0x18(%rsp... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::HashEntry::operator=(hlkvds::HashEntry const&) | HashEntry& HashEntry::operator=(const HashEntry& toBeCopied) {
*entryPtr_ = *toBeCopied.entryPtr_;
*stampPtr_ = *toBeCopied.stampPtr_;
cachePtr_ = toBeCopied.cachePtr_;
return *this;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x24fd0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq 0x8(%rax), %rdi
callq 0x276d0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx)... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::InitMeta(unsigned int, unsigned long, unsigned long, unsigned int) | void IndexManager::InitMeta(uint32_t ht_size, uint64_t ondisk_size, uint64_t data_theory_size, uint32_t element_num) {
htSize_ = ht_size;
sizeOndisk_ = ondisk_size;
initHashTable();
//Set dataTheorySize
dataTheorySize_ = data_theory_size;
keyCounter_ = element_num;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x8(%rdi)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rdi)
callq 0x25750
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::Get(char*, unsigned long) | bool IndexManager::Get(char* buff, uint64_t length) {
if (length != sizeOndisk_) {
return false;
}
char* buf_ptr = buff;
//Copy TS
int64_t time_len = KVTime::SizeOf();
lastTime_->Update();
time_t t = lastTime_->GetTime();
memcpy((void *)buf_ptr, (const void*)&t, time_len);
b... | subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x98(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x88(%rsp), %rax
cmpq 0x10(%rcx), %rax
je 0x258f7
movb $0x0, 0xa7(%rsp)
jmp 0x25b07
movq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
callq 0x116e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rc... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::Set(char*, unsigned long) | bool IndexManager::Set(char* buff, uint64_t length) {
if (length != sizeOndisk_) {
return false;
}
char* buf_ptr = buff;
//Set TS
int64_t time_len = KVTime::SizeOf();
time_t t;
memcpy((void *)&t, (const void*)buf_ptr, time_len);
lastTime_->SetTime(t);
buf_ptr += time_len;
... | subq $0xf8, %rsp
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rdx, 0xd8(%rsp)
movq 0xe8(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0xd8(%rsp), %rax
cmpq 0x10(%rcx), %rax
je 0x25b77
movb $0x0, 0xf7(%rsp)
jmp 0x25e98
movq 0xe0(%rsp), %rax
movq %rax, 0xd0(%rsp)
callq 0x116e0
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rsi
mo... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::UpdateIndex(hlkvds::KVSlice*, bool) | bool IndexManager::UpdateIndex(KVSlice* slice, bool gc_update) {
const Kvdb_Digest *digest = &slice->GetDigest();
HashEntry entry = slice->GetHashEntry();
const char* data = slice->GetData();
uint32_t hash_index = KeyDigestHandle::Hash(digest) % htSize_;
if (gc_update) {
HashEntry entry_... | subq $0x168, %rsp # imm = 0x168
movb %dl, %al
movq %rdi, 0x158(%rsp)
movq %rsi, 0x150(%rsp)
andb $0x1, %al
movb %al, 0x14f(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x150(%rsp), %rdi
callq 0x16d90
movq %rax, 0x140(%rsp)
movq 0x150(%rsp), %rdi
callq 0x116b0
movq %rax, %rsi
leaq 0x128(%rsp), %rdi... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::IsSameInMem(hlkvds::HashEntry&) | bool IndexManager::IsSameInMem(HashEntry &entry)
{
Kvdb_Digest digest = entry.GetKeyDigest();
uint32_t hash_index = KeyDigestHandle::Hash(&digest) % htSize_;
std::lock_guard<std::mutex> l(hashtable_[hash_index].slotMtx_);
LinkedList<HashEntry> *entry_list = hashtable_[hash_index].entryList_;
bool ... | subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xb0(%rsp), %rsi
leaq 0x9c(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x276a0
movq 0x40(%rsp), %rdi
callq 0x2a0b0
movl %eax, 0x4c(%rsp)
jmp 0x2665e
movq 0x38(%rsp), %rcx
movl 0x4c(%rsp), %eax
movl 0x8(%rcx), %ecx
... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::UpdateIndexes(std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&) | void IndexManager::UpdateIndexes(list<KVSlice*> &slice_list) {
std::lock_guard<std::mutex> l(batch_mtx_);
for (list<KVSlice *>::iterator iter = slice_list.begin(); iter
!= slice_list.end(); iter++) {
KVSlice *slice = *iter;
UpdateIndex(slice);
} __DEBUG("UpdateToIndex Success!");... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x70, %rsi
leaq 0x40(%rsp), %rdi
callq 0xb5f0
movq 0x48(%rsp), %rdi
callq 0x16410
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x16460
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
call... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::RemoveEntry(hlkvds::HashEntry) | void IndexManager::RemoveEntry(HashEntry entry) {
Kvdb_Digest digest = entry.GetKeyDigest();
uint32_t hash_index = KeyDigestHandle::Hash(&digest) % htSize_;
std::unique_lock<std::mutex> meta_lck(mtx_, std::defer_lock);
std::lock_guard<std::mutex> l(hashtable_[hash_index].slotMtx_);
LinkedList<Hash... | subq $0x108, %rsp # imm = 0x108
movq %rsi, 0x40(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0xe4(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x276a0
movq 0x50(%rsp), %rdi
callq 0x2a0b0
movl %eax, 0x5c(%rsp)
jmp 0x2697b
movq 0x48(%rsp), %rsi
movl 0x5c(%rsp)... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::GetHashEntry(hlkvds::KVSlice*) | bool IndexManager::GetHashEntry(KVSlice *slice) {
const Kvdb_Digest *digest = &slice->GetDigest();
uint32_t hash_index = KeyDigestHandle::Hash(digest) % htSize_;
HashEntry entry;
entry.SetKeyDigest(*digest);
std::lock_guard<std::mutex> l(hashtable_[hash_index].slotMtx_);
LinkedList<HashEntry> *... | subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x16d90
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x2a0b0
movq 0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
xorl %edx, %edx
divl %ecx
movl %edx, 0xa4(%rsp)
leaq 0x88(%rsp), %rdi
movq %rd... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::UpdateIndexesForGC(std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&) | void IndexManager::UpdateIndexesForGC(std::list<KVSlice*> &slice_list) {
std::lock_guard<std::mutex> l(batch_mtx_);
for (list<KVSlice *>::iterator iter = slice_list.begin(); iter
!= slice_list.end(); iter++) {
KVSlice *slice = *iter;
UpdateIndex(slice, true);
} __DEBUG("UpdateToI... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x70, %rsi
leaq 0x40(%rsp), %rdi
callq 0xb5f0
movq 0x48(%rsp), %rdi
callq 0x16410
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x16460
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
call... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::CalcIndexSizeOnDevice(unsigned int) | uint64_t IndexManager::CalcIndexSizeOnDevice(uint32_t ht_size) {
uint64_t index_size = sizeof(time_t)
+ sizeof(int) * ht_size
+ IndexManager::SizeOfHashEntryOnDisk() * ht_size;
uint64_t index_size_pages = index_size / getpagesize();
return (index_size_pages + 1) * getpagesize();
} | subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl 0x34(%rsp), %eax
shlq $0x2, %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
callq 0x166b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl 0x34(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x8860
movl %eax, %ecx
movq ... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::~IndexManager() | IndexManager::~IndexManager() {
if (lastTime_) {
delete lastTime_;
}
if (hashtable_) {
destroyHashTable();
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x40(%rax)
je 0x27201
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x271ff
movq (%rsp), %rdi
callq 0x50920
movq (%rsp), %rdi
callq 0x84b0
jmp 0x27201
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je ... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::IndexManager::CalcHashSizeForPower2(unsigned int) | uint32_t IndexManager::CalcHashSizeForPower2(uint32_t number) {
// Gets the next highest power of 2 larger than number
number--;
number = (number >> 1) | number;
number = (number >> 2) | number;
number = (number >> 4) | number;
number = (number >> 8) | number;
number = (number >> 16) | numbe... | movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x2, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x4, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
... | yangwanyuan[P]HLKVDS/src/IndexManager.cc |
hlkvds::LinkedList<hlkvds::HashEntry>::get() | std::vector<T> LinkedList<T>::get() {
std::vector<T> tempVector;
if (head_ != NULL) {
Node<T>* tempNode = head_;
while (tempNode != NULL) {
tempVector.push_back(tempNode->data);
tempNode = tempNode->next;
}
}
return tempVector;
} | subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x28130
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x27839
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, ... | yangwanyuan[P]HLKVDS/./src/include/LinkedList.h |
hlkvds::LinkedList<hlkvds::HashEntry>::put(hlkvds::HashEntry&) | bool LinkedList<T>::put(T& toBePuted) {
bool is_new = true;
Node<T>* newNode = new Node<T> (toBePuted, NULL);
if (head_ == NULL) {
head_ = newNode;
size_++;
} else {
Node<T>* curNode = head_;
Node<T>* preNode;
while (curNode != NULL) {
if (curNode->da... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x1, 0x67(%rsp)
movl $0x20, %edi
callq 0x84f0
movq %rax, 0x18(%rsp)
movb $0x1, 0x33(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x252e0
jmp 0x27a12
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, ... | yangwanyuan[P]HLKVDS/./src/include/LinkedList.h |
hlkvds::LinkedList<hlkvds::HashEntry>::search(hlkvds::HashEntry&) | bool LinkedList<T>::search(T& toBeSearched) {
Node<T>* curNode = head_;
while (curNode != NULL) {
if (curNode->data == toBeSearched) {
return true;
}
curNode = curNode->next;
}
return false;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x27bcf
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x25440
testb $0x1, %al
jne 0x27bb8
jmp 0x27bbf
movb $0x1, 0x27(%rsp)
jmp 0x27bd4
movq 0x8(%rsp), %rax
movq 0x18(%rax... | yangwanyuan[P]HLKVDS/./src/include/LinkedList.h |
hlkvds::LinkedList<hlkvds::HashEntry>::getRef(hlkvds::HashEntry) | T* LinkedList<T>::getRef(T toBeGeted) {
Node<T>* tempNode = head_;
while (tempNode != NULL) {
if (tempNode->data == toBeGeted) {
return &tempNode->data;
}
tempNode = tempNode->next;
}
return NULL;
} | subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x27c37
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x25440
testb $0x1, %al
jne 0x27c1b
jmp 0x27c27
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x27c40
... | yangwanyuan[P]HLKVDS/./src/include/LinkedList.h |
hlkvds::HashEntry::LogicStamp::operator<(hlkvds::HashEntry::LogicStamp const&) | bool operator<(const LogicStamp& toBeCopied) {
if ((segTime_ < toBeCopied.segTime_) || (segTime_
== toBeCopied.segTime_ && (keyNo_ < toBeCopied.keyNo_))) {
return true;
}
return false;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
callq 0x50820
testb $0x1, %al
jne 0x27cad
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x50890
testb $0x1, %al
jne 0x27c9b
jmp 0x27cb4
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x10(%r... | yangwanyuan[P]HLKVDS/./src/include/IndexManager.h |
hlkvds::LinkedList<hlkvds::HashEntry>::remove(hlkvds::HashEntry&) | bool LinkedList<T>::remove(T& toBeRemoved) {
bool flag = false;
if (head_ == NULL) {
return flag;
}
Node<T>* preNode = head_;
Node<T>* curNode = preNode->next;
if (head_->data == toBeRemoved) {
head_ = curNode;
delete preNode;
size_--;
flag = true;
}... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x2f(%rsp)
cmpq $0x0, (%rax)
jne 0x27d12
movb 0x2f(%rsp), %al
andb $0x1, %al
movb %al, 0x47(%rsp)
jmp 0x27e16
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x18(... | yangwanyuan[P]HLKVDS/./src/include/LinkedList.h |
hlkvds::LinkedList<hlkvds::HashEntry>::removeAll() | void LinkedList<T>::removeAll() {
Node<T>* tempNode = head_;
while (tempNode != NULL) {
tempNode = head_->next;
delete head_;
head_ = tempNode;
}
size_ = 0;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x28095
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x28086
movq 0x8(%rsp)... | yangwanyuan[P]HLKVDS/./src/include/LinkedList.h |
hlkvds::KernelDevice::set_device_zero() | int KernelDevice::set_device_zero() {
int r = 0;
lseek(bufFd_, 0, SEEK_SET);
r = fill_file_with_zeros();
if (r < 0) {
__ERROR("Could not zero out DB file.\n");
return KD_ERR;
}
return KD_OK;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl 0xc(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x88b0
movq 0x8(%rsp), %rdi
callq 0x28f70
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x28f56
jmp 0x28ee0
movq 0x480f1(%rip), %rax # ... | yangwanyuan[P]HLKVDS/src/KernelDevice.cc |
hlkvds::KernelDevice::fill_file_with_zeros() | int KernelDevice::fill_file_with_zeros() {
size_t nbytes = capacity_;
static const size_t BLOCKSIZE = 8192;
char zeros[BLOCKSIZE];
memset(zeros, 0, BLOCKSIZE);
while (nbytes > 0) {
size_t bytes_to_write = min(nbytes, BLOCKSIZE);
ssize_t ret = write(bufFd_, zeros, bytes_to_write);
... | subq $0x2048, %rsp # imm = 0x2048
movq %rdi, 0x2038(%rsp)
movq 0x2038(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x2030(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x2000, %edx # imm = 0x2000
callq 0x8280
cmpq $0x0, 0x2030(%rsp)
jbe 0x290b2
leaq 0x2030(%rsp), %rdi
leaq ... | yangwanyuan[P]HLKVDS/src/KernelDevice.cc |
hlkvds::KernelDevice::get_block_device_capacity() | uint64_t KernelDevice::get_block_device_capacity() {
uint64_t blocksize;
if (ioctl(bufFd_, BLKGETSIZE64, &blocksize) < 0) {
__ERROR("Could not get block size: %s\n", strerror(errno));
return KD_ERR;
}
return blocksize;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0xc(%rax), %edi
movl $0x80081272, %esi # imm = 0x80081272
leaq 0x10(%rsp), %rdx
movb $0x0, %al
callq 0x86d0
cmpl $0x0, %eax
jge 0x2918d
jmp 0x290fd
movq 0x47ed4(%rip), %rax # 0x70fd8
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x8480
movq (%rsp),... | yangwanyuan[P]HLKVDS/src/KernelDevice.cc |
hlkvds::KernelDevice::lock_device() | int KernelDevice::lock_device()
{
struct flock l;
memset(&l, 0, sizeof(l));
l.l_type = F_WRLCK;
l.l_whence = SEEK_SET;
int r = ::fcntl(directFd_, F_SETLK, &l);
if (r < 0) {
return KD_ERR;
}
return KD_OK;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x8280
movq 0x8(%rsp), %rax
movw $0x1, 0x18(%rsp)
movw $0x0, 0x1a(%rsp)
movl 0x8(%rax), %edi
movl $0x6, %esi
leaq 0x18(%rsp), %rdx
movb $0x0, %al
callq 0x82a0
movl %eax, 0x14(%r... | yangwanyuan[P]HLKVDS/src/KernelDevice.cc |
hlkvds::KernelDevice::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) | int KernelDevice::Open(string path, bool dsync) {
if (isOpen_) {
__ERROR("This Device is already Open!!!");
return KD_ERR;
}
path_ = path;
int r = 0;
directFd_ = open(path_.c_str(), O_RDWR | O_DIRECT | O_DSYNC, 0666);
if (directFd_ < 0) {
__ERROR("Could not open file: ... | subq $0x148, %rsp # imm = 0x148
movq %rsi, 0x88(%rsp)
movb %dl, %al
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
andb $0x1, %al
movb %al, 0x12f(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x90(%rsp)
testb $0x1, 0x40(%rax)
je 0x292fa
jmp 0x29276
movq 0x47d5b(%rip), %rax # 0x70fd8
movq (%rax), %rax
movq %rax,... | yangwanyuan[P]HLKVDS/src/KernelDevice.cc |
hlkvds::KernelDevice::Close() | void KernelDevice::Close() {
isOpen_ = false;
if (directFd_ != -1) {
close(directFd_);
}
if (bufFd_ != -1) {
close(bufFd_);
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x40(%rax)
cmpl $-0x1, 0x8(%rax)
je 0x298aa
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x8900
movq 0x8(%rsp), %rax
cmpl $-0x1, 0xc(%rax)
je 0x298c2
movq 0x8(%rsp), %rax
movl 0xc(%rax), %edi
callq 0x8900
addq $0x18, %rsp
re... | yangwanyuan[P]HLKVDS/src/KernelDevice.cc |
hlkvds::KernelDevice::pWrite(void const*, unsigned long, long) | ssize_t KernelDevice::pWrite(const void* buf, size_t count, off_t offset) {
if (IsPageAligned(buf) &&
IsSectorAligned(count) &&
IsSectorAligned(offset)) {
return DirectWriteAligned(buf, count, offset);
}
__INFO("Buffered FD Pwrite, write size = %ld, block_size = %d",
coun... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x40(%rsp), %rsi
callq 0x29b70
testb $0x1, %al
jne 0x29902
jmp 0x2994f
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x29bb0
testb $0x1, %al
jne 0x29917
jmp 0x299... | yangwanyuan[P]HLKVDS/src/KernelDevice.cc |
hlkvds::KeyDigestHandle::CalcDigest(hlkvds::Kvdb_Key const*, hlkvds::Kvdb_Digest&) | void KeyDigestHandle::CalcDigest(const Kvdb_Key *key, Kvdb_Digest &digest)
/*
* returns RMD(message)
* message should be a string terminated by '\0'
*/
{
dword MDbuf[RMDsize / 32]; /* contains (A, B, C, D(, E)) */
//static byte hashcode[RMDsize/8]; /* for final hash-value */
byte hashcode[RMD... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xcb60
movq 0xa0(%rsp), %rdi
callq 0x2a280
movl %eax, 0x18(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x2a290
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x3f, 0x14(%rsp)
jbe 0x29f50
movl $0x0, 0x1c(%rsp)
cmpl $0x... | yangwanyuan[P]HLKVDS/src/KeyDigestHandle.cc |
hlkvds::KeyDigestHandle::Hash(hlkvds::Kvdb_Key const*) | uint32_t KeyDigestHandle::Hash(const Kvdb_Key *key) {
Kvdb_Digest result;
CalcDigest(key, result);
uint32_t hash_value = Hash(&result);
return hash_value;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x2c(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x29ce0
movq 0x10(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x29e70
jmp 0x2a059
leaq 0x2c(%rsp), %rdi
callq 0x2a0b0
movl %eax, 0xc(%rsp)
jmp 0x2a069
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsp... | yangwanyuan[P]HLKVDS/src/KeyDigestHandle.cc |
hlkvds::KeyDigestHandle::Hash(hlkvds::Kvdb_Digest const*) | uint32_t KeyDigestHandle::Hash(const Kvdb_Digest *digest) {
uint32_t hash_value;
const uint32_t *pi = &digest->value[4];
unsigned char key_char[4];
key_char[0] = *((const char *) pi + 0);
key_char[1] = *((const char *) pi + 1);
key_char[2] = *((const char *) pi + 2);
key_char[3] = *((const c... | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movb (%rax), %al
movb %al, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movb 0x1(%rax), %al
movb %al, -0x1b(%rsp)
movq -0x18(%rsp), %rax
movb 0x2(%rax), %al
movb %al, -0x1a(%rsp)
movq -0x18(%rsp), %rax
movb 0x3(%rax), %al
m... | yangwanyuan[P]HLKVDS/src/KeyDigestHandle.cc |
hlkvds::KeyDigestHandle::Tostring[abi:cxx11](hlkvds::Kvdb_Digest*) | string KeyDigestHandle::Tostring(Kvdb_Digest *digest) {
int digest_size = KeyDigestHandle::SizeOfDigest();
unsigned char *temp = digest->GetDigest();
int str_len = 2 * digest_size + 1;
char *res = new char[str_len];
for (int i = 0; i < digest_size; i++) {
sprintf(&res[2 * i], "%02x", temp[i... | subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
callq 0x2a270
movl %eax, 0x64(%rsp)
movq 0x68(%rsp), %rdi
callq 0x2a2a0
movq %rax, 0x58(%rsp)
movl 0x64(%rsp), %eax
shll %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
movslq 0x54(%rsp), %rdi
movq $-0x1,... | yangwanyuan[P]HLKVDS/src/KeyDigestHandle.cc |
hlkvds::DB::CreateDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hlkvds::Options) | bool DB::CreateDB(string filename, Options opts) {
KVDS* new_kvds;
new_kvds = KVDS::Create_KVDS(filename.c_str(), opts);
if (!new_kvds) {
std::cout << "CreateDB failed" << std::endl;
return false;
}
delete new_kvds;
return true;
} | subq $0xd8, %rsp
leaq 0xe0(%rsp), %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0xc8(%rsp)
callq 0x8180
movq 0x60(%rsp), %rsi
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
movl $0x50, %edx
callq 0x8410
movq 0x68(%rsp), %rdi
movups 0xb0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movups 0x70(%rsp), %xmm0
movups 0x80(%rs... | yangwanyuan[P]HLKVDS/src/Kvdb.cc |
hlkvds::DB::OpenDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hlkvds::DB**, hlkvds::Options) | bool DB::OpenDB(string filename, DB** db, Options opts) {
std::unique_lock<std::mutex> l(db_->mtx_);
if ( db_->kvds_ == NULL ) {
db_->kvds_ = KVDS::Open_KVDS(filename.c_str(), opts);
if (!db_->kvds_) {
std::cout << "OpenDB failed" << std::endl;
return false;
}
... | subq $0xf8, %rsp
movq %rdi, 0x60(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x68(%rsp)
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
leaq 0x471f0(%rip), %rax # 0x715d0
movq (%rax), %rsi
addq $0x10, %rsi
leaq 0xd0(%rsp), %rdi
callq 0x15a10
leaq 0x471d5(%rip), %rax # 0x715d0
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne ... | yangwanyuan[P]HLKVDS/src/Kvdb.cc |
hlkvds::DB::Insert(char const*, unsigned int, char const*, unsigned short, bool) | Status DB::Insert(const char* key, uint32_t key_len, const char* data,
uint16_t length, bool immediately) {
Status s = kvds_->Insert(key, key_len, data, length, immediately);
if (!s.ok()) {
std::cout << "DB Insert failed" << std::endl;
}
return s;
} | subq $0x78, %rsp
movl %r9d, %eax
movl %ecx, 0x1c(%rsp)
movq %rdx, %rcx
movl 0x1c(%rsp), %edx
movq %rcx, 0x20(%rsp)
movq %rsi, %r9
movq 0x20(%rsp), %rsi
movq %rdi, 0x30(%rsp)
movw %ax, %cx
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movb 0x80(%rsp), %al
movq %rdi, 0x70(%rsp)
movq %r9, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %ed... | yangwanyuan[P]HLKVDS/src/Kvdb.cc |
hlkvds::DB::Delete(char const*, unsigned int) | Status DB::Delete(const char* key, uint32_t key_len) {
Status s = kvds_->Delete(key, key_len);
if (!s.ok()) {
std::cout << "DB Delete failed" << std::endl;
}
return s;
} | subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movb $0x0, 0x2b(%rsp)
movq 0x8(%rax), %rsi
movq 0x30(%rsp), %rdx
movl 0x2c(%rsp), %ecx
callq 0x2c9b0
movq 0x10(%rsp), %rdi
callq 0xa89... | yangwanyuan[P]HLKVDS/src/Kvdb.cc |
hlkvds::DB::Get(char const*, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | Status DB::Get(const char* key, uint32_t key_len, string &data) {
Status s = kvds_->Get(key, key_len, data);
if (!s.ok()) {
std::cout << "DB Get failed" << std::endl;
}
return s;
} | subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movq 0x48(%rsp), %rax
movb $0x0, 0x2f(%rsp)
movq 0x8(%rax), %rsi
movq 0x40(%rsp), %rdx
movl 0x3c(%rsp), %ecx
movq 0x30(%rsp), %r8
callq... | yangwanyuan[P]HLKVDS/src/Kvdb.cc |
hlkvds::KvdbIter::SeekToFirst() | void KvdbIter::SeekToFirst() {
LinkedList<HashEntry> *entry_list;
hashEntry_ = NULL;
htSize_ = idxMgr_->GetHashTableSize();
for (int i = 0; i < htSize_; i++) {
entry_list = idxMgr_->GetEntryListByNo(i);
int entry_list_size = entry_list->get_size();
if (entry_list_size > 0) {
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rax)
movq 0x8(%rax), %rdi
callq 0x2b480
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x38(%rax)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x38(%rcx), %eax
jge 0x2ac8d
movq 0x8(%rsp), %rax
mo... | yangwanyuan[P]HLKVDS/src/KvdbIter.cc |
hlkvds::KvdbIter::SeekToLast() | void KvdbIter::SeekToLast() {
LinkedList<HashEntry> *entry_list;
hashEntry_ = NULL;
htSize_ = idxMgr_->GetHashTableSize();
for (int i = htSize_ - 1; i >= 0; i--) {
entry_list = idxMgr_->GetEntryListByNo(i);
int entry_list_size = entry_list->get_size();
//__INFO("entry_list_size=%... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rax)
movq 0x8(%rax), %rdi
callq 0x2b480
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x38(%rax)
movl 0x38(%rax), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x2ad6b
movq 0x8(%rsp), %rax
movq 0x8... | yangwanyuan[P]HLKVDS/src/KvdbIter.cc |
hlkvds::KvdbIter::Seek(char const*) | void KvdbIter::Seek(const char* key) {
//need hashEntry;
int key_len = strlen(key);
KVSlice slice(key, key_len, NULL, 0);
DataHeader data_header;
data_header.SetDigest(slice.GetDigest());
DataHeaderAddress addrs;
HashEntry entry(data_header, addrs, NULL);
LinkedList<HashEntry> *entr... | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xf8(%rsp), %rdi
callq 0x81b0
movl %eax, 0xf4(%rsp)
movq 0xf8(%rsp), %rsi
movl 0xf4(%rsp), %edx
xorl %r9d, %r9d
movl %r9d, %ecx
leaq 0xb0(%rsp), %rdi
movl %r9d, %r8d
callq 0x40eb0
le... | yangwanyuan[P]HLKVDS/src/KvdbIter.cc |
hlkvds::KvdbIter::Next() | void KvdbIter::Next() {
LinkedList<HashEntry> *entry_list;
entry_list = idxMgr_->GetEntryListByNo(hashTableCur_);
hashEntry_ = NULL;
int entry_list_size = entry_list->get_size();
if ( entryListCur_ < entry_list_size - 1) {
entryListCur_++;
hashEntry_ = entry_list->getByNo(entryListCu... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
movl 0x3c(%rax), %esi
callq 0x2b490
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rdi
callq 0x277a0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rsp)
movl ... | yangwanyuan[P]HLKVDS/src/KvdbIter.cc |
hlkvds::KvdbIter::Prev() | void KvdbIter::Prev() {
LinkedList<HashEntry> *entry_list;
entry_list = idxMgr_->GetEntryListByNo(hashTableCur_);
hashEntry_ = NULL;
int entry_list_size = entry_list->get_size();
if (entryListCur_ > 0) {
entryListCur_--;
hashEntry_ = entry_list->getByNo(entryListCur_);
} else {
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
movl 0x3c(%rax), %esi
callq 0x2b490
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rdi
callq 0x277a0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rsp)
cmpl ... | yangwanyuan[P]HLKVDS/src/KvdbIter.cc |
hlkvds::LinkedList<hlkvds::HashEntry>::getByNo(int) | T* LinkedList<T>::getByNo(int no) {
if (no > size_) {
return NULL;
}
Node<T>* node = head_;
while(no) {
node = node->next;
no--;
}
return &node->data;
} | movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x28(%rsp)
movl -0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
jle 0x2b4d7
movq $0x0, -0x8(%rsp)
jmp 0x2b510
movq -0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
cmpl $0x0, -0x14(%rsp)
je 0x2b506
movq -0x20(%rsp), %rax
movq 0x18(%rax), ... | yangwanyuan[P]HLKVDS/./src/include/LinkedList.h |
hlkvds::LinkedList<hlkvds::HashEntry>::searchNo(hlkvds::HashEntry&) | int LinkedList<T>::searchNo(T& toBeSearched) {
int no = 0;
Node<T>* curNode = head_;
while (curNode != NULL) {
if (curNode->data == toBeSearched) {
return no;
}
curNode = curNode->next;
no++;
}
return -1;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl $0x0, 0xc(%rsp)
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2b580
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x25440
testb $0x1, %al
jne 0x2b55d
jmp 0x2b567
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x2b588
mo... | yangwanyuan[P]HLKVDS/./src/include/LinkedList.h |
hlkvds::KVDS::Create_KVDS(char const*, hlkvds::Options) | KVDS* KVDS::Create_KVDS(const char* filename, Options opts) {
if (filename == NULL) {
return NULL;
}
KVDS* kvds = new KVDS(filename, opts);
if (!kvds->openAllDevices(kvds->paths_)) {
delete kvds;
return NULL;
}
int datastor_type = opts.datastor_type;
kvds->dataStor... | subq $0x148, %rsp # imm = 0x148
leaq 0x150(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq %rdi, 0x138(%rsp)
cmpq $0x0, 0x138(%rsp)
jne 0x2b5fb
movq $0x0, 0x140(%rsp)
jmp 0x2b971
movl $0xc0, %edi
callq 0x84f0
movq %rax, %rdi
movq 0xa0(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x98(%rsp)
movq 0x138(%rsp), %rsi
movups 0x4... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::openAllDevices(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | bool KVDS::openAllDevices(string paths) {
vector<string> fields;
boost::split(fields, paths, boost::is_any_of(FileDelim));
vector<string>::iterator iter;
for(iter = fields.begin(); iter != fields.end(); iter++){
BlockDevice *bdev = new KernelDevice();
if (bdev->Open(*iter) < 0) {
... | subq $0xd8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x2d200
leaq 0x45c1b(%rip), %rsi # 0x715e8
leaq 0x90(%rsp), %rdi
callq 0x2d300
jmp 0x2b9dc
movq 0x20(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::printDbStates() | void KVDS::printDbStates() {
sbMgr_->printSBInfo();
dataStor_->printDeviceTopologyInfo();
idxMgr_->printDynamicInfo();
dataStor_->printDynamicInfo();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rax), %rdi
callq 0x49390
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x25630
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::Open_KVDS(char const*, hlkvds::Options) | KVDS* KVDS::Open_KVDS(const char* filename, Options opts) {
KVDS *kvds = new KVDS(filename, opts);
Status s = kvds->openDB();
if (!s.ok()) {
delete kvds;
return NULL;
}
kvds->isOpen_ = true;
return kvds;
} | subq $0x108, %rsp # imm = 0x108
leaq 0x110(%rsp), %rax
movq %rax, 0x68(%rsp)
movq %rdi, 0xf8(%rsp)
movl $0xc0, %edi
callq 0x84f0
movq %rax, %rdi
movq 0x68(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x70(%rsp)
movq 0xf8(%rsp), %rsi
movups 0x40(%rax), %xmm0
movaps %xmm0, 0xe0(%rsp)
movups (%rax), %xmm0
movups 0x10... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::openDB() | Status KVDS::openDB() {
if (!openAllDevices(paths_)) {
return Status::IOError("Could not open all device");
}
int datastor_type = -1;
if ( !metaStor_->TryLoadSB(datastor_type)) {
return Status::IOError("Could not load SB");
}
dataStor_ = DataStor::Create(options_, bdVec_, sbMgr... | subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rsi
movq %rsi, 0x20(%rsp)
addq $0x8, %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x81a0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2b990
movb %al, 0x37(%rsp)
jmp... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::closeDB() | Status KVDS::closeDB() {
if (!metaStor_->PersistMetaData()) {
__ERROR("Could not to write metadata to device\n");
return Status::IOError("Could not to write metadata to device");
}
stopThds();
return Status::OK();
} | subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rax), %rdi
callq 0x35830
testb $0x1, %al
jne 0x2c189
jmp 0x2c108
movq 0x44ec9(%rip), %rax # 0x70fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
c... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::~KVDS() | KVDS::~KVDS() {
if (isOpen_) {
closeDB();
}
delete idxMgr_;
delete sbMgr_;
if(!options_.disable_cache){
delete rdCache_;
}
delete metaStor_;
if (dataStor_) {
delete dataStor_;
}
closeAllDevices();
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x4443e(%rip), %rcx # 0x70638
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0xb8(%rax)
je 0x2c225
movq 0x28(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x2c0d0
jmp 0x2c21b
leaq 0x30(%rsp), %rdi
callq 0xa8b0
movq 0x28(%rsp), %rax
mo... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::closeAllDevices() | void KVDS::closeAllDevices() {
vector<BlockDevice *>::iterator iter;
for ( iter = bdVec_.begin() ; iter != bdVec_.end(); ) {
BlockDevice *bdev = *iter;
delete bdev;
iter = bdVec_.erase(iter);
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2d580
movq 0x18(%rsp), %rdi
addq $0xa0, %rdi
callq 0x2d5a0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x18(%rsp), %rdi
addq $0xa0, %rdi
callq 0x2d610
movq %rax, 0x38(%rsp)
leaq 0x... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::KVDS(char const*, hlkvds::Options) | KVDS::KVDS(const char* filename, Options opts) :
paths_(string(filename)), sbMgr_(NULL), idxMgr_(NULL), rdCache_(NULL), metaStor_(NULL), dataStor_(NULL), options_(opts), isOpen_(false) {
sbMgr_ = new SuperBlockManager(options_);
idxMgr_ = new IndexManager(sbMgr_, options_);
if(!options_.disable_cache)... | subq $0x78, %rsp
leaq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x441bc(%rip), %rcx # 0x70638
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x67(%rsp)... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::Insert(char const*, unsigned int, char const*, unsigned short, bool) | Status KVDS::Insert(const char* key, uint32_t key_len, const char* data,
uint16_t length, bool immediately) {
if (key == NULL || key[0] == '\0') {
return Status::InvalidArgument("Key is null or empty.");
}
KVSlice slice(key, key_len, data, length);
Status s = dataStor_->W... | subq $0x118, %rsp # imm = 0x118
movl %r9d, %eax
movl %ecx, 0x24(%rsp)
movq %rdx, %rcx
movl 0x24(%rsp), %edx
movq %rcx, 0x28(%rsp)
movq %rsi, %rcx
movq 0x28(%rsp), %rsi
movq %rcx, 0x30(%rsp)
movq %rdi, %r9
movq 0x30(%rsp), %rdi
movq %r9, 0x38(%rsp)
movw %ax, %cx
movq %r9, %rax
movq %rax, 0x40(%rsp)
movb 0x120... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::Get(char const*, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | Status KVDS::Get(const char* key, uint32_t key_len, string &data) {
bool res = false;
if (key == NULL) {
return Status::InvalidArgument("Key is null.");
}
KVSlice slice(key, key_len, NULL, 0);
if(!options_.disable_cache) {
if(rdCache_->Get(slice.GetKeyStr(), data)) {
rd... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x160(%rsp)
movq %rsi, 0x158(%rsp)
movq %rdx, 0x150(%rsp)
movl %ecx, 0x14c(%rsp)
movq %r8, 0x140(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x0, 0x13f(%rsp)
cmpq $0x0, 0x150(%rsp)
jne 0x2ca71
... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.