name stringlengths 1 4.98k | code stringlengths 61 2.07M | asm stringlengths 57 12.9M | file stringlengths 18 192 |
|---|---|---|---|
hlkvds::KVDS::InsertBatch(hlkvds::WriteBatch*) | Status KVDS::InsertBatch(WriteBatch *batch) {
if (batch->batch_.empty()) {
return Status::OK();
}
Status s = dataStor_->WriteBatchData(batch);
if (s.ok()) {
if(!options_.disable_cache) {
for (std::list<KVSlice *>::iterator iter = batch->batch_.begin();
i... | subq $0xb8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x239b0
testb $0x1, %al
jne 0x2ce4c
jmp 0x2ce5b
movq 0x18(%rsp), %rdi
callq 0x16560
jmp 0x2d02c
movq 0x18... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::KVDS::ClearReadCache() | void KVDS::ClearReadCache() {
vector<BlockDevice*>::iterator iter;
for (iter = bdVec_.begin(); iter != bdVec_.end(); iter++) {
BlockDevice *bdev = *iter;
bdev->ClearReadCache();
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2d580
movq (%rsp), %rdi
addq $0xa0, %rdi
callq 0x2d5a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq (%rsp), %rdi
addq $0xa0, %rdi
callq 0x2d610
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %r... | yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc |
hlkvds::MetaStor::TryLoadSB(int&) | bool MetaStor::TryLoadSB(int &datastor_type) {
verifyMetaDevice();
//Load SuperBlock
sbOff_ = 0;
if (!loadSuperBlock()) {
__ERROR("Load SuperBlock failed.");
return false;
}
datastor_type = sbMgr_->GetDataStoreType();
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x34170
movq 0x8(%rsp), %rdi
movq $0x0, 0x38(%rdi)
callq 0x34280
testb $0x1, %al
jne 0x34258
jmp 0x341e5
movq 0x3cdec(%rip), %rax # 0x70fd8
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x8480
movq (%rsp), %rdi... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::loadSuperBlock() | bool MetaStor::loadSuperBlock() {
uint64_t length = SuperBlockManager::SuperBlockSizeOnDevice();
char *buff = new char[length];
memset(buff, 0, length);
if ((uint64_t) metaDev_->pRead(buff, length, sbOff_) != length){
__ERROR("Could not read superblock from device at %ld\n", sbOff_);
de... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x117e0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x8040
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rdx
xorl %esi, %esi
callq 0x8280
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x38(%rsp), %rsi
movq ... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::CreateMetaData() | bool MetaStor::CreateMetaData() {
verifyMetaDevice();
uint32_t index_ht_size = 0;
uint64_t index_region_offset = 0;
uint64_t index_region_length = 0;
uint32_t sst_total_num = 0;
uint64_t sst_region_offset = 0;
uint64_t sst_region_length = 0;
uint32_t d... | pushq %rbp
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x158(%rsp)
movq 0x158(%rsp), %rdi
movq %rdi, 0x88(%rsp)
callq 0x34170
movq 0x88(%rsp), %rax
movl $0x0, 0x154(%rsp)
movq $0x0, 0x148(%rsp)
movq $0x0, 0x140(%rsp)
movl $0x0, 0x13c(%rsp)
movq $0x0, 0x130(%rsp)
movq $0x0, 0x128(%rsp)
movl $0x0, 0x... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::createSuperBlock() | bool MetaStor::createSuperBlock() {
uint64_t length = SuperBlockManager::SuperBlockSizeOnDevice();
char *buff = new char[length];
memset(buff, 0, length);
if (!sbMgr_->Set(buff, length))
{
__ERROR("Can't Set SuperBlock, Load Failed!");
delete[] buff;
return false;
}
... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x117e0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8040
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
xorl %esi, %esi
callq 0x8280
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rsi
movq ... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::createIndex(unsigned int, unsigned long) | bool MetaStor::createIndex(uint32_t ht_size, uint64_t index_size) {
idxMgr_->InitMeta(ht_size, index_size, 0, 0);
uint64_t length = index_size;
char *buff = new char[length];
memset(buff, 0, length);
if(!idxMgr_->Set(buff, length)){
__ERROR("Can't Set Index Region, Load Failed!");
... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rax), %rdi
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x256f0
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::createDataStor() | bool MetaStor::createDataStor() {
if (!dataStor_->CreateAllComponents(sstOff_)) {
__ERROR("Can't Create DataStore");
return false;
}
uint64_t length = dataStor_->GetSSTsLengthOnDisk();
char *buff = new char[length];
memset(buff, 0 , length);
if (!dataStor_->SetAllSSTs(buff, le... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rax), %rdi
movq 0x48(%rax), %rsi
movq (%rdi), %rax
callq *0x80(%rax)
testb $0x1, %al
jne 0x34d92
jmp 0x34d1a
movq 0x3c2b7(%rip), %rax # 0x70fd8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x8480
movq 0x18(%rsp), %rdi
mov... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::zeroDeviceMetaRegion(unsigned long) | bool MetaStor::zeroDeviceMetaRegion(uint64_t meta_size) {
if (meta_size % 4096 != 0) {
return false;
}
char *align_buf;
int block_size = metaDev_->GetBlockSize();
block_size = (block_size > 4096? block_size : 4096);
int ret = posix_memalign((void **)&align_buf, 4096, (size_t)block_size... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
andq $0xfff, %rax # imm = 0xFFF
cmpq $0x0, %rax
je 0x34ee3
movb $0x0, 0x77(%rsp)
jmp 0x35101
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::LoadMetaData() | bool MetaStor::LoadMetaData() {
//Load Index
uint32_t index_ht_size = sbMgr_->GetHTSize();
uint64_t sb_region_length = SuperBlockManager::SuperBlockSizeOnDevice();
uint64_t index_region_length = sbMgr_->GetIndexRegionLength();
idxOff_ = sbOff_ + sb_region_length;
if(!loadIndex(index_ht_size, i... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rax), %rdi
callq 0x36250
movl %eax, 0x34(%rsp)
callq 0x117e0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x18(%rax), %rdi
callq 0x36260
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x38(%rdi), %rax
add... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::loadIndex(unsigned int, unsigned long) | bool MetaStor::loadIndex(uint32_t ht_size, uint64_t index_size) {
idxMgr_->InitMeta(ht_size, index_size, sbMgr_->GetDataTheorySize(), sbMgr_->GetEntryCount());
uint64_t length = index_size;
char *buff = new char[length];
memset(buff, 0, length);
if ((uint64_t) metaDev_->pRead(buff, length, idxOff_... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movl %esi, 0x74(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x30(%rsp)
movl 0x74(%rsp), %ecx
movl %ecx, 0x3c(%rsp)
movq 0x68(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movq 0x18(%rax), %rdi
callq 0x36270
movq %rax, %rcx
movq 0x50... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::loadDataStor() | bool MetaStor::loadDataStor() {
uint64_t reserved_region_length = SuperBlockManager::ReservedRegionLength();
char *reserved_content = new char[reserved_region_length];
if ( !sbMgr_->GetReservedContent(reserved_content, reserved_region_length) ) {
delete[] reserved_content;
return false;
... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x50(%rsp)
callq 0x116c0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x8040
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x68(%rsp)
movq 0x18(%rax), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x49880
testb $0x1, %al
jne 0x3555... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::PersistMetaData() | bool MetaStor::PersistMetaData() {
if (!PersistIndexToDevice()) {
__WARN("Persist Index failed.");
return false;
}
if (!PersistSSTsToDevice()) {
__WARN("Persist SSTs failed.");
return false;
}
if (!persistSuperBlockToDevice()) {
__WARN("Persist SB failed.");... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x359f0
testb $0x1, %al
jne 0x358c6
jmp 0x3584e
movq 0x3b783(%rip), %rax # 0x70fd8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x8480
movq 0x18(%rsp), %rdi
movq %rax, %rdx
leaq 0x1d48c(%rip), %rsi # 0x52cfd
leaq 0x1db18(%... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::PersistIndexToDevice() | bool MetaStor::PersistIndexToDevice() {
int ret = false;
char *align_buf;
uint64_t length = sbMgr_->GetIndexRegionLength();
ret = posix_memalign((void **)&align_buf, 4096, length);
if (ret < 0) {
__ERROR("Can't allocate memory for Index, Persist Failed!");
return false;
}
mem... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x18(%rax), %rdi
callq 0x36260
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movl $0x1000, %esi # imm = 0x1000
callq 0x8230
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
jge 0x35ab2
... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::PersistSSTsToDevice() | bool MetaStor::PersistSSTsToDevice() {
int ret = false;
char *align_buf;
uint64_t length = sbMgr_->GetSSTRegionLength();
ret = posix_memalign((void **)&align_buf, 4096, length);
if (ret < 0) {
__ERROR("Can't allocate memory for SSTs, Persist Failed!");
return false;
}
memset(... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x64(%rsp)
movq 0x18(%rax), %rdi
callq 0x167b0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdx
leaq 0x58(%rsp), %rdi
movl $0x1000, %esi # imm = 0x1000
callq 0x8230
movl %eax, 0x64(%rsp)
cmpl $0x0, 0x64(%rsp)
jge 0x35d02
... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::MetaStor::persistSuperBlockToDevice() | bool MetaStor::persistSuperBlockToDevice() {
int ret = false;
char *align_buf;
uint64_t length = SuperBlockManager::SuperBlockSizeOnDevice();
ret = posix_memalign((void **)&align_buf, 4096, length);
if (ret < 0) {
__ERROR("Can't allocate memory for SuperBlock, Persist Failed!");
retu... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x34(%rsp)
callq 0x117e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movl $0x1000, %esi # imm = 0x1000
callq 0x8230
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
jge 0x35ffe
jmp 0x35f86
movq 0x3b0... | yangwanyuan[P]HLKVDS/src/MetaStor.cc |
hlkvds::Migrate::ForeMigrate(unsigned int) | uint32_t Migrate::ForeMigrate(uint32_t mt_vol_id) {
std::lock_guard <std::mutex> lck(mtx_);
//Get the sorted Segments
Volume *ft_vol = ft_->GetVolume();
//check free segment;
uint32_t free_seg_num = ft_vol->GetTotalFreeSegs();
if (free_seg_num > SEG_RESERVED_FOR_GC) {
__DEBUG("some thr... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x18(%rsp)
addq $0x20, %rsi
leaq 0x48(%rsp), %rdi
callq 0xb5f0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x37250
movq %rax, 0x20(%rsp)
jmp 0x36389
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5... | yangwanyuan[P]HLKVDS/src/Migrate.cc |
hlkvds::Migrate::doMigrate(unsigned int, unsigned int) | uint32_t Migrate::doMigrate(uint32_t mt_vol_id, uint32_t max_seg_num) {
Volume *ft_vol = ft_->GetVolume();
Volume *mt_vol = mt_->GetVolume(mt_vol_id);
std::multimap < uint32_t, uint32_t > cands_map;
ft_vol->SortSegsByTS(cands_map, max_seg_num);
//do merge
bool ret = false;
std::vector <uin... | subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x168(%rsp)
movl %esi, 0x164(%rsp)
movl %edx, 0x160(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x50(%rsp)
movq (%rax), %rdi
callq 0x37250
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x158(%rsp)
movq 0x8(%rax), %rdi
movl 0x164(%rsp), %esi
callq 0x4e810
movq %rax, 0... | yangwanyuan[P]HLKVDS/src/Migrate.cc |
hlkvds::Migrate::loadKvList(unsigned int, std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&) | bool Migrate::loadKvList(uint32_t seg_id, std::list<KVSlice*> &slice_list) {
uint64_t seg_phy_off;
Volume *ft_vol = ft_->GetVolume();
ft_vol->CalcSegOffsetFromId(seg_id, seg_phy_off);
memset(ftDataBuf_, 0 , ftSegSize_);
if (!ft_vol->Read(ftDataBuf_, ftSegSize_, seg_phy_off)) {
return fals... | 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
callq 0x37250
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl 0x64(%rsp), %esi
leaq 0x50(%rsp), %rdx
callq 0x23960
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
movl 0x50(%rax)... | yangwanyuan[P]HLKVDS/src/Migrate.cc |
hlkvds::Migrate::loadSegKV(std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&, unsigned int, unsigned long) | void Migrate::loadSegKV(list<KVSlice*> &slice_list, uint32_t num_keys,
uint64_t phy_offset) {
uint32_t head_offset = SegBase::SizeOfSegOnDisk();
Volume *ft_vol = ft_->GetVolume();
int vol_id = ft_vol->GetId();
for (uint32_t index = 0; index < num_keys; index++) {
Data... | 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, 0x40(%rsp)
callq 0x166a0
movq %rax, %rcx
movq 0x40(%rsp), %rax
movl %ecx, 0xf4(%rsp)
movq (%rax), %rdi
callq 0x37250
movq %rax, 0xe8(%rsp)
movq 0xe8(%rs... | yangwanyuan[P]HLKVDS/src/Migrate.cc |
dslab::ReadCache::Put(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void ReadCache::Put(string key, string value){
//get footprint
WriteLock w_lock(myLock);
hlkvds::Kvdb_Key input(value.c_str(),value.length());
hlkvds::Kvdb_Digest result;
em->CalcDigest(&input,result);
string footprint = em->Tostring(&result);
string tobeUpdate = "", lkey ="", lvalue = "";//useless key, useless ... | subq $0x408, %rsp # imm = 0x408
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xe8(%rsp)
movq %rdi, 0x400(%rsp)
movq %rsi, 0x3f8(%rsp)
movq %rdx, 0x3f0(%rsp)
movq 0x400(%rsp), %rsi
movq %rsi, 0xe0(%rsp)
addq $0x70, %rsi
leaq 0x3e0(%rsp), %rdi
callq 0x388b0
movq 0xe8(%rsp), %rdi
callq 0x8180
movq 0xe8(%rsp), %rdi
movq %ra... | yangwanyuan[P]HLKVDS/src/ReadCache.cc |
dslab::ReadCache::Get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool ReadCache::Get(string key, string &value){
ReadLock r_lock(myLock);
map<string, string>::iterator it_dedup = dedup_map.find(key);
if( it_dedup!=dedup_map.end() ){
return cache_map->Get(it_dedup->second, value);
}
else{
value = "";
return false;
}
} | subq $0xa8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x98(%rsp), %rsi
movq %rsi, 0x18(%rsp)
addq $0x70, %rsi
leaq 0x78(%rsp), %rdi
callq 0x38c50
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x8, %rdi
callq 0x388e0
movq %rax, 0x28(%rsp)
jmp 0x381e9
movq 0x18(... | yangwanyuan[P]HLKVDS/src/ReadCache.cc |
dslab::ReadCache::Delete(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void ReadCache::Delete(string key){
WriteLock w_lock(myLock);
map<string, string>::iterator it_dedup = dedup_map.find(key);
if(it_dedup!=dedup_map.end()){
multimap<string, string>::iterator it_refer = refer_map.find( it_dedup->second);
for(int i = 0; i < refer_map.count( it_dedup->second); i++){
if(it_refer-... | subq $0xf8, %rsp
movq %rsi, 0x58(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rsi
movq %rsi, 0x50(%rsp)
addq $0x70, %rsi
leaq 0xd8(%rsp), %rdi
callq 0x388b0
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
addq $0x8, %rdi
callq 0x388e0
movq %rax, 0x60(%rsp)
jmp 0x38364
movq 0x50(%rsp), %rdi
movq 0x60(... | yangwanyuan[P]HLKVDS/src/ReadCache.cc |
dslab::CacheMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::create(dslab::CachePolicy, unsigned long, unsigned long) | CacheMap<K, D> *CacheMap<K, D>::create(CachePolicy policy, size_t cache_size, size_t probation){
if(policy == LRU){
return new LRUMap<K, D> (cache_size);
}else{
size_t protect = cache_size-probation;
return new SLRUMap<K, D> (protect, probation);
}
} | subq $0x48, %rsp
movl %edi, 0x3c(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0x387c0
movl $0x70, %edi
callq 0x84f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
callq 0x39bf0
jmp 0x3879a
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x3881b
movq 0x8(%rsp), %... | yangwanyuan[P]HLKVDS/./src/include/CacheMap.h |
dslab::LRUMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::LRUMap(unsigned long) | LRUMap(size_t size){
if(size <= 0)
size = 1024;
entries = new Node<K,D>[size];
for(size_t i = 0; i < size; ++i)
free_entries.push_back(entries + i);
head = new Node<K,D>;
tail = new Node<K,D>;
head->prev = NULL;
head->next = tail;
... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x39ec0
movq 0x48(%rsp), %rdi
leaq 0x36d16(%rip), %rax # 0x70938
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x40(%rsp)
callq 0x39ee0
movq 0x48(%rsp), %rdi
addq $0x40, %rdi
movq %rdi, 0x5... | yangwanyuan[P]HLKVDS/./src/include/LRUMap.h |
dslab::LRUMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Put(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std:... | bool LRUMap<K,D>::Put(K key , D data, K& update_key, D& update_data, bool same){
update_key = K();
update_data = D();
Node<K,D> *node = cached_map[key];
bool poped;
if(node){//key exist
detach(node);
if(!same){
node->data = data;
}
attach(node);
poped = false;//no data po... | subq $0xa8, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movb %r9b, %al
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
andb $0x1, %al
movb %al, 0x7f(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x86a0
movq 0x88(%rsp), %rd... | yangwanyuan[P]HLKVDS/./src/include/LRUMap.h |
dslab::LRUMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std:... | bool LRUMap<K,D>::Get(K key, D& data){
Node<K,D> *node = cached_map[key];
if(node){
detach(node);
attach(node);
data = node->data;
return true;
}
else{
data = D();
return false;
}
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x3b4b0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x3a38e
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3b4e0
movq 0x8(%rsp), %rdi
movq 0x30(%rs... | yangwanyuan[P]HLKVDS/./src/include/LRUMap.h |
dslab::LRUMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Delete(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | bool LRUMap<K,D>::Delete(K key){
Node<K,D> *node = cached_map[key];
if(node){
detach(node);
free_entries.push_back(node);
cached_map.erase(node->key);
return true;
}
else{
return false;
}
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
callq 0x3b4b0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3a439
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3b4e0
movq (%rsp), %rdi
addq $0x40, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3... | yangwanyuan[P]HLKVDS/./src/include/LRUMap.h |
dslab::LRUMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::attach(dslab::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_tra... | void attach(Node<K,D>* node){
node->prev = head;
node->next = head->next;
head->next = node;
node->next->prev = node;
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x58(%rax), %rdx
movq -0x10(%rsp), %rcx
movq %rdx, 0x40(%rcx)
movq 0x58(%rax), %rcx
movq 0x48(%rcx), %rdx
movq -0x10(%rsp), %rcx
movq %rdx, 0x48(%rcx)
movq -0x10(%rsp), %rcx
movq 0x58(%rax), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rsp), %rcx
movq -0... | yangwanyuan[P]HLKVDS/./src/include/LRUMap.h |
dslab::SLRUMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Put(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std... | bool SLRUMap<K,D>::Put(K key , D data, K& ukey, D& udata, bool same){
D ldata;
if( Get(key, ldata) ){//key exists, it should be now in protect segment, the segments should have been renewed
return protect.Put(key, data, ukey, udata, same);//always false, no kv poped
}else{// key does not exist
return probation.P... | subq $0x158, %rsp # imm = 0x158
movq %rdx, 0x30(%rsp)
movq %rsi, 0x40(%rsp)
movb %r9b, %al
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movq %rdx, 0x138(%rsp)
movq %rcx, 0x130(%rsp)
movq %r8, 0x128(%rsp)
andb $0x1, %al
movb %al, 0x127(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x100(%rsp), %rdi... | yangwanyuan[P]HLKVDS/./src/include/SLRUMap.h |
dslab::SLRUMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std... | bool SLRUMap<K,D>::Get(K key, D& data){
K ukey, lkey;
D udata, ldata;
if( probation.Get(key, data) ){//key exists in probation
bool poped = protect.Put(key, data, ukey, udata);//kv poped out
probation.Delete(key);//need a place to insert abandoned key from protected list
if( poped ){
probation.Put(ukey, uda... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rsi, 0x40(%rsp)
movq %rdi, 0x1d8(%rsp)
movq %rsi, 0x1d0(%rsp)
movq %rdx, 0x1c8(%rsp)
movq 0x1d8(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x1a8(%rsp), %rdi
callq 0x86a0
leaq 0x188(%rsp), %rdi
callq 0x86a0
leaq 0x168(%rsp), %rdi
callq 0x86a0
leaq 0x148(%rsp), %rdi
callq 0x86... | yangwanyuan[P]HLKVDS/./src/include/SLRUMap.h |
hlkvds::SegHeaderOnDisk::SegHeaderOnDisk(hlkvds::SegHeaderOnDisk const&) | SegHeaderOnDisk::SegHeaderOnDisk(const SegHeaderOnDisk& toBeCopied) {
timestamp = toBeCopied.timestamp;
trx_id = toBeCopied.trx_id;
trx_segs = toBeCopied.trx_segs;
checksum_data = toBeCopied.checksum_data;
checksum_length = toBeCopied.checksum_length;
number_keys = toBeCopied.number_keys;
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rsp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::KVSlice::~KVSlice() | KVSlice::~KVSlice() {
if (deepCopy_) {
delete[] key_;
delete[] data_;
}
if (digest_) {
delete digest_;
}
if (entry_) {
delete entry_;
}
if (entryGC_) {
delete entryGC_;
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
testb $0x1, 0x34(%rax)
je 0x40c96
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x40c76
movq 0x20(%rsp), %rdi
callq 0x8610
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %r... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::KVSlice::copy_helper(hlkvds::KVSlice const&) | void KVSlice::copy_helper(const KVSlice& toBeCopied) {
keyLength_ = toBeCopied.GetKeyLen();
dataLength_ = toBeCopied.GetDataLen();
key_ = toBeCopied.GetKey();
data_ = toBeCopied.GetData();
*digest_ = *toBeCopied.digest_;
*entry_ = *toBeCopied.entry_;
segId_ = toBeCopied.segId_;
deepCopy_... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x44260
movw %ax, %cx
movq (%rsp), %rax
movzwl %cx, %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x163a0
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x18(%rax)
movq 0x8(%rsp), %rdi
callq ... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::KVSlice::KVSlice(char const*, int, char const*, int, bool) | KVSlice::KVSlice(const char* key, int key_len, const char* data, int data_len, bool deep_copy) :
key_(NULL), keyLength_(key_len), data_(NULL), dataLength_(data_len),
digest_(NULL), entry_(NULL), segId_(0), deepCopy_(deep_copy),
entryGC_(NULL) {
if (deepCopy_) {
key_ = new char[ke... | subq $0x38, %rsp
movb %r9b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
andb $0x1, %al
movb %al, 0x13(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rax)
movl 0x24(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl 0x14(%rsp),... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::KVSlice::calcDigest() | void KVSlice::calcDigest() {
if (digest_) {
delete digest_;
digest_=nullptr;
}
digest_ = new Kvdb_Digest();
Kvdb_Key vkey(key_, keyLength_);
KeyDigestHandle::CalcDigest(&vkey, *digest_);
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rax)
je 0x4101f
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x41012
movq 0x18(%rsp), %rdi
callq 0x29d50
movq 0x18(%rsp), %rdi
callq 0x84b0
movq 0x20(%rsp), %rax
movq $0x0, 0x20(%r... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::KVSlice::SetKeyValue(char const*, int, char const*, int) | void KVSlice::SetKeyValue(const char* key, int key_len, const char* data,
int data_len) {
keyLength_ = key_len;
dataLength_ = data_len;
key_ = key;
data_ = data;
calcDigest();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rdi)
movl 0x4(%rsp), %eax
movw %ax, 0x18(%rdi)
movq 0x18(%rsp), %rax
movq %rax, (%rdi)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rdi)
callq... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::Request::operator=(hlkvds::Request const&) | Request& Request::operator=(const Request& toBeCopied) {
done_ = toBeCopied.done_;
stat_ = toBeCopied.stat_;
slice_ = toBeCopied.slice_;
segPtr_ = toBeCopied.segPtr_;
return *this;
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq 0x68(%rcx), %rcx
movq %... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegBase::copyHelper(hlkvds::SegBase const&) | void SegBase::copyHelper(const SegBase& toBeCopied) {
segId_ = toBeCopied.segId_;
vol_ = toBeCopied.vol_;
segSize_ = toBeCopied.segSize_;
headPos_ = toBeCopied.headPos_;
tailPos_ = toBeCopied.tailPos_;
keyNum_ = toBeCopied.keyNum_;
keyAlignedNum_ = toBeCopied.keyAlignedNum_;
memcpy(dataB... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movl 0x14(%rcx... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegBase::Put(hlkvds::KVSlice*) | void SegBase::Put(KVSlice* slice) {
if (slice->IsAlignedData()) {
headPos_ += IndexManager::SizeOfDataHeader() + slice->GetKeyLen();
tailPos_ -= ALIGNED_SIZE;
keyAlignedNum_++;
} else {
headPos_ += IndexManager::SizeOfDataHeader() + slice->GetKeyLen() + slice->GetDataLen();
}... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x442d0
testb $0x1, %al
jne 0x41988
jmp 0x419cf
callq 0x238d0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x44260
movq 0x18(%rsp), %rdx
movw %ax, %cx
movq 0x20(%rsp), %rax
movzwl %c... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegBase::TryPutList(std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&) | bool SegBase::TryPutList(std::list<KVSlice*> &slice_list) {
uint32_t freeSize = tailPos_ - headPos_;
uint32_t needSize = 0;
for (list<KVSlice *>::iterator iter = slice_list.begin(); iter != slice_list.end(); iter++) {
KVSlice *slice = *iter;
needSize += slice->GetDataLen() + slice->GetKeyLen... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rcx
movl 0x18(%rcx), %eax
subl 0x14(%rcx), %eax
movl %eax, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x16410
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x16460
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegBase::WriteSegToDevice() | bool SegBase::WriteSegToDevice() {
if (segId_ < 0)
{
__ERROR("Not set seg_id to segment");
return false;
}
fillEntryToSlice();
__DEBUG("Begin write seg, free size %u, seg id: %d, key num: %d", tailPos_-headPos_ , segId_, keyNum_);
return _writeDataToDevice();
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, (%rax)
jge 0x41c3f
jmp 0x41bca
movq 0x2f407(%rip), %rax # 0x70fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x8480
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x108c4(%rip), %rsi # 0x524b1
leaq 0x1259b(%rip), %rcx ... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegBase::fillEntryToSlice() | void SegBase::fillEntryToSlice() {
uint32_t head_pos = SegBase::SizeOfSegOnDisk();
uint32_t tail_pos = segSize_;
int vol_id = vol_->GetId();
for (list<KVSlice *>::iterator iter = sliceList_.begin(); iter
!= sliceList_.end(); iter++) {
KVSlice *slice = *iter;
slice->SetSegId(... | subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x170(%rsp)
movq 0x170(%rsp), %rax
movq %rax, 0x68(%rsp)
callq 0x166a0
movq %rax, %rcx
movq 0x68(%rsp), %rax
movl %ecx, 0x16c(%rsp)
movl 0x10(%rax), %ecx
movl %ecx, 0x168(%rsp)
movq 0x8(%rax), %rdi
callq 0x238c0
movq 0x68(%rsp), %rdi
movl %eax, 0x164(%rsp)
addq $0x2... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegBase::_writeDataToDevice() | bool SegBase::_writeDataToDevice() {
posix_memalign((void **)&dataBuf_, 4096, segSize_);
copyToDataBuf();
uint64_t offset = 0;
vol_->CalcSegOffsetFromId(segId_, offset);
bool ret = vol_->Write(dataBuf_, segSize_, offset);
free(dataBuf_);
dataBuf_ = NULL;
return ret;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, %rdi
addq $0x40, %rdi
movslq 0x10(%rax), %rdx
movl $0x1000, %esi # imm = 0x1000
callq 0x8230
movq 0x8(%rsp), %rdi
callq 0x42380
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rsp)
movq 0x8(%rax), %rdi
movl (%rax), %esi
leaq 0x... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegBase::copyToDataBuf() | void SegBase::copyToDataBuf() {
uint64_t offset = 0;
vol_->CalcSegOffsetFromId(segId_, offset);
uint32_t offset_begin = 0;
uint32_t offset_end = segSize_;
offset_begin += SegBase::SizeOfSegOnDisk();
//aggregate iovec
for (list<KVSlice *>::iterator iter = sliceList_.begin(); iter
... | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0xd8(%rsp)
movq 0x8(%rax), %rdi
movl (%rax), %esi
leaq 0xd8(%rsp), %rdx
callq 0x23960
movq 0x30(%rsp), %rax
movl $0x0, 0xd4(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0xd0(%rsp)
callq 0x166a0
movq 0x30(%rsp), %rdi
movq %rax, %rcx
... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegForReq::operator=(hlkvds::SegForReq const&) | SegForReq& SegForReq::operator=(const SegForReq& toBeCopied) {
if (this == &toBeCopied) {
return *this;
}
SegBase::operator=(toBeCopied);
idxMgr_ = toBeCopied.idxMgr_;
timeout_ = toBeCopied.timeout_;
startTime_ = toBeCopied.startTime_;
persistTime_ = toBeCopied.persistTime_;
isC... | subq $0x78, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq 0x30(%rsp), %rax
jne 0x4292e
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x42af1
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x41830
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rax
m... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegForReq::TryPut(hlkvds::Request*) | bool SegForReq::TryPut(Request* req) {
if (isCompletion_) {
return false;
}
KVSlice *slice= &req->GetSlice();
return SegBase::TryPut(slice);
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x78(%rax)
je 0x42c14
movb $0x0, 0x27(%rsp)
jmp 0x42c37
movq 0x10(%rsp), %rdi
callq 0x16a90
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x418e0
andb $0x1, %al
movb %al, 0x27(%rsp)
movb ... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegForReq::Put(hlkvds::Request*) | void SegForReq::Put(Request* req) {
KVSlice *slice = &req->GetSlice();
if (GetKeyNum() == 0) {
hasReq_ = true;
startTime_.Update();
}
SegBase::Put(slice);
reqList_.push_back(req);
req->SetSeg(this);
__DEBUG("Put request key = %s", req->GetSlice().GetKeyStr().c_str());
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x16a90
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x44420
cmpl $0x0, %eax
jne 0x42c98
movq 0x8(%rsp), %rdi
movb $0x1, 0x79(%rdi)
addq $0x58, %rdi
callq 0x50710
movq 0x8(%rsp), %rdi
... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegForReq::Notify(bool) | void SegForReq::Notify(bool stat) {
std::lock_guard < std::mutex > l(mtx_);
//Set logic timestamp to hashentry
reqCommited_.store(GetKeyNum());
int32_t keyNo = 0;
persistTime_.Update();
for (list<Request *>::iterator iter = reqList_.begin(); iter
!= reqList_.end(); iter++) {
... | subq $0xd8, %rsp
movb %sil, %al
movq %rdi, 0xb8(%rsp)
andb $0x1, %al
movb %al, 0xb7(%rsp)
movq 0xb8(%rsp), %rsi
movq %rsi, 0x40(%rsp)
addq $0x98, %rsi
leaq 0xa8(%rsp), %rdi
callq 0xb5f0
movq 0x40(%rsp), %rdi
movq %rdi, %rax
addq $0x7c, %rax
movq %rax, 0x48(%rsp)
callq 0x44420
movl %eax, 0x54(%rsp)
jmp 0x42d68
movl 0x54... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegForReq::IsExpired() | bool SegForReq::IsExpired() {
KVTime nowTime;
if (!hasReq_) {
return false;
}
int64_t interval = nowTime - startTime_;
return (interval > timeout_);
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x50730
movq 0x10(%rsp), %rax
testb $0x1, 0x79(%rax)
jne 0x43067
movb $0x0, 0x57(%rsp)
movl $0x1, 0x34(%rsp)
jmp 0x430c8
movq 0x10(%rsp), %rsi
addq $0x58, %rsi
leaq 0x38(%rsp), %rdi
callq 0x508e0
movq %rax, 0x... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegForReq::CleanDeletedEntry() | void SegForReq::CleanDeletedEntry() {
std::lock_guard < std::mutex > l(mtx_);
for (list<HashEntry>::iterator iter = delReqList_.begin(); iter
!= delReqList_.end(); iter++) {
idxMgr_->RemoveEntry(*iter);
}
delReqList_.clear();
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rsi
movq %rsi, 0x10(%rsp)
addq $0x98, %rsi
leaq 0x58(%rsp), %rdi
callq 0xb5f0
movq 0x10(%rsp), %rdi
addq $0xc0, %rdi
callq 0x44620
movq %rax, 0x50(%rsp)
movq 0x10(%rsp), %rdi
addq $0xc0, %rdi
callq 0x44670
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rs... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegForSlice::operator=(hlkvds::SegForSlice const&) | SegForSlice& SegForSlice::operator=(const SegForSlice& toBeCopied) {
if (this == &toBeCopied) {
return *this;
}
SegBase::operator=(toBeCopied);
idxMgr_ = toBeCopied.idxMgr_;
return *this;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq 0x10(%rsp), %rax
jne 0x432bb
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x432e1
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x41830
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x48(%rcx), %rcx
movq ... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegForMigrate::operator=(hlkvds::SegForMigrate const&) | SegForMigrate& SegForMigrate::operator=(const SegForMigrate& toBeCopied) {
if (this == &toBeCopied) {
return *this;
}
SegBase::operator=(toBeCopied);
idxMgr_ = toBeCopied.idxMgr_;
return *this;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq 0x10(%rsp), %rax
jne 0x433db
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x43401
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x41830
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x48(%rcx), %rcx
movq ... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegLatencyFriendly::copyHelper(hlkvds::SegLatencyFriendly const&) | void SegLatencyFriendly::copyHelper(const SegLatencyFriendly& toBeCopied) {
segId_ = toBeCopied.segId_;
vol_ = toBeCopied.vol_;
segSize_ = toBeCopied.segSize_;
headPos_ = toBeCopied.headPos_;
keyNum_ = toBeCopied.keyNum_;
checksumSize_ = toBeCopied.checksumSize_;
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rsp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegLatencyFriendly::Put(hlkvds::KVSlice*) | void SegLatencyFriendly::Put(KVSlice* slice) {
headPos_ += IndexManager::SizeOfDataHeader() + slice->GetKeyLen() + slice->GetDataLen();
keyNum_++;
sliceList_.push_back(slice);
__DEBUG("Put request key = %s", slice->GetKeyStr().c_str());
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x238d0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x44260
movw %ax, %cx
movq (%rsp), %rax
movzwl %cx, %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x163a0
movq 0x8(%rsp), %rcx
movq... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegLatencyFriendly::TryPutList(std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&) | bool SegLatencyFriendly::TryPutList(std::list<KVSlice*> &slice_list) {
uint32_t free_size = segSize_ - headPos_;
uint32_t need_size = 0;
for (list<KVSlice *>::iterator iter = slice_list.begin(); iter != slice_list.end(); iter++) {
KVSlice *slice = *iter;
need_size += slice->GetDataLen() + sl... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rcx
movl 0x14(%rcx), %eax
subl 0x18(%rcx), %eax
movl %eax, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x16410
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x16460
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegLatencyFriendly::fillEntryToSlice() | void SegLatencyFriendly::fillEntryToSlice() {
uint32_t head_pos = SegBase::SizeOfSegOnDisk();
int vol_id = vol_->GetId();
for (list<KVSlice *>::iterator iter = sliceList_.begin(); iter
!= sliceList_.end(); iter++) {
KVSlice *slice = *iter;
slice->SetSegId(segId_);
uint3... | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
callq 0x166a0
movq %rax, %rcx
movq 0x40(%rsp), %rax
movl %ecx, 0xdc(%rsp)
movq (%rax), %rdi
callq 0x238c0
movq 0x40(%rsp), %rdi
movl %eax, 0xd8(%rsp)
addq $0x28, %rdi
callq 0x16410
movq %rax, 0xd0(%rsp)
movq 0x40(%rsp), %rdi
addq $0x28, ... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegLatencyFriendly::_writeDataToDevice() | bool SegLatencyFriendly::_writeDataToDevice() {
checksumSize_ = headPos_ - SegBase::SizeOfSegOnDisk();
uint32_t pages_num = headPos_ / getpagesize();
uint32_t aligned_size = ( pages_num + 1 ) * getpagesize();
posix_memalign((void**)&dataBuf_, 4096, aligned_size);
copyToDataBuf();
uint64_t offs... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x18(%rax), %eax
movq %rax, (%rsp)
callq 0x166a0
movq (%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
subq %rdx, %rcx
movl %ecx, 0x20(%rax)
movl 0x18(%rax), %eax
movl %eax, 0x8(%rsp)
callq 0x8860
movl %eax, %ecx
movl 0x8(%rsp), %... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegLatencyFriendly::copyToDataBuf() | void SegLatencyFriendly::copyToDataBuf() {
uint64_t offset = 0;
vol_->CalcSegOffsetFromId(segId_, offset);
uint32_t offset_begin = 0;
offset_begin += SegBase::SizeOfSegOnDisk();
//aggregate iovec
for (list<KVSlice *>::iterator iter = sliceList_.begin(); iter
!= sliceList_.end(); i... | subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0xc8(%rsp)
movq (%rax), %rdi
movl 0x10(%rax), %esi
leaq 0xc8(%rsp), %rdx
callq 0x23960
movl $0x0, 0xc4(%rsp)
callq 0x166a0
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl 0xc4(%rsp), %eax
addq %rcx, %rax
movl %eax, 0xc4(%rsp)
addq ... | yangwanyuan[P]HLKVDS/src/Segment.cc |
hlkvds::SegmentManager::Get(char*, unsigned long) | bool SegmentManager::Get(char* buf, uint64_t length) {
uint64_t stat_size = SegmentManager::SizeOfSegmentStat();
uint64_t stat_table_size = stat_size * segNum_;
if (length != stat_table_size) {
return false;
}
char *buf_ptr = buf;
for (uint32_t seg_idx = 0; seg_idx < segNum_; seg_idx++) ... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x47a90
movq 0x10(%rsp), %rcx
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl 0x20(%rcx), %ecx
imulq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x46e... | yangwanyuan[P]HLKVDS/src/SegmentManager.cc |
hlkvds::SegmentManager::Set(char*, unsigned long) | bool SegmentManager::Set(char* buf, uint64_t length) {
uint64_t stat_size = SegmentManager::SizeOfSegmentStat();
uint64_t stat_table_size = stat_size * segNum_;
if (length != stat_table_size) {
return false;
}
char* buf_ptr = buf;
for (uint32_t seg_idx = 0; seg_idx < segNum_; seg_idx++) ... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x47a90
movq 0x8(%rsp), %rcx
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movl 0x20(%rcx), %ecx
imulq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x46fd3... | yangwanyuan[P]HLKVDS/src/SegmentManager.cc |
hlkvds::SegmentManager::Alloc(unsigned int&) | bool SegmentManager::Alloc(uint32_t& seg_id) {
std::unique_lock <std::mutex> l(mtx_);
if (freedCounter_ <= SEG_RESERVED_FOR_GC) {
return false;
}
l.unlock();
return AllocForGC(seg_id);
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rsi
movq %rsi, 0x10(%rsp)
addq $0x40, %rsi
leaq 0x30(%rsp), %rdi
callq 0x15a10
movq 0x10(%rsp), %rax
cmpl $0x2, 0x2c(%rax)
ja 0x470f0
movb $0x0, 0x57(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0x4713f
leaq 0x30(%rsp), %rdi
callq 0x16e30
jmp 0x470fc
mov... | yangwanyuan[P]HLKVDS/src/SegmentManager.cc |
hlkvds::SegmentManager::AllocForGC(unsigned int&) | bool SegmentManager::AllocForGC(uint32_t& seg_id) {
//for first use !!
std::lock_guard <std::mutex> l(mtx_);
if (segTable_[curSegId_].state == SegUseStat::FREE) {
seg_id = curSegId_;
segTable_[curSegId_].state = SegUseStat::RESERVED;
reservedCounter_++;
freedCounter_--;
... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x40, %rsi
leaq 0x18(%rsp), %rdi
callq 0xb5f0
movq 0x8(%rsp), %rdi
movl 0x24(%rdi), %eax
movl %eax, %esi
callq 0x47aa0
cmpl $0x0, (%rax)
jne 0x471e5
movq 0x8(%rsp), %rdi
movl 0x24(%rdi), %ecx
movq 0x20(%rsp), %... | yangwanyuan[P]HLKVDS/src/SegmentManager.cc |
hlkvds::SegmentManager::FreeForFailed(unsigned int) | void SegmentManager::FreeForFailed(uint32_t seg_id) {
std::lock_guard <std::mutex> l(mtx_);
segTable_[seg_id].state = SegUseStat::FREE;
segTable_[seg_id].free_size = 0;
segTable_[seg_id].death_size = 0;
reservedCounter_--;
freedCounter_++;
__DEBUG("Free Segment seg_id = %d", seg_id);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x40, %rsi
leaq 0x10(%rsp), %rdi
callq 0xb5f0
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x47aa0
movq 0x8(%rsp), %rdi
movl $0x0, (%rax)
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x47aa0
... | yangwanyuan[P]HLKVDS/src/SegmentManager.cc |
hlkvds::SegmentManager::FreeForGC(unsigned int) | void SegmentManager::FreeForGC(uint32_t seg_id) {
std::lock_guard <std::mutex> l(mtx_);
segTable_[seg_id].state = SegUseStat::FREE;
segTable_[seg_id].free_size = 0;
segTable_[seg_id].death_size = 0;
usedCounter_--;
freedCounter_++;
__DEBUG("Free Segment For GC, seg_id = %d", seg_id);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x40, %rsi
leaq 0x10(%rsp), %rdi
callq 0xb5f0
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x47aa0
movq 0x8(%rsp), %rdi
movl $0x0, (%rax)
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x47aa0
... | yangwanyuan[P]HLKVDS/src/SegmentManager.cc |
hlkvds::SegmentManager::Use(unsigned int, unsigned int) | void SegmentManager::Use(uint32_t seg_id, uint32_t free_size) {
std::lock_guard <std::mutex> l(mtx_);
segTable_[seg_id].state = SegUseStat::USED;
segTable_[seg_id].free_size = free_size;
reservedCounter_--;
usedCounter_++;
__DEBUG("Used Segment seg_id = %d, free_size = %d", seg_id, free_size);
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x40, %rsi
leaq 0x10(%rsp), %rdi
callq 0xb5f0
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x47aa0
movq 0x8(%rsp), %rdi
movl $0x1, (%rax)
movl 0x18(%rsp), %eax
movl %ea... | yangwanyuan[P]HLKVDS/src/SegmentManager.cc |
hlkvds::SegmentManager::SortSegsByUtils(std::multimap<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>&, double) | void SegmentManager::SortSegsByUtils( std::multimap<uint32_t, uint32_t> &cand_map, double utils) {
std::lock_guard <std::mutex> lck(mtx_);
uint32_t used_size;
uint32_t thld = (uint32_t)(segSize_ * utils);
for (uint32_t index = 0; index < segNum_; index++) {
if (segTable_[index].state == SegUseS... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movsd %xmm0, 0x70(%rsp)
movq 0x80(%rsp), %rsi
movq %rsi, 0x30(%rsp)
addq $0x40, %rsi
leaq 0x68(%rsp), %rdi
callq 0xb5f0
movq 0x30(%rsp), %rax
movl 0x18(%rax), %eax
cvtsi2sd %rax, %xmm0
movsd 0x70(%rsp), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax... | yangwanyuan[P]HLKVDS/src/SegmentManager.cc |
hlkvds::SegmentManager::SortSegsByTS(std::multimap<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>&, unsigned int) | void SegmentManager::SortSegsByTS(std::multimap<uint32_t, uint32_t> &cand_map, uint32_t max_seg_num)
{
std::unique_lock<std::mutex> lck(mtx_, std::defer_lock);
uint32_t used_size;
lck.lock();
std::multimap<uint32_t, uint32_t> used_map;
for (uint32_t index = 0; index < segNum_; index++) {
if... | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movl %edx, 0xd4(%rsp)
movq 0xe0(%rsp), %rsi
movq %rsi, 0x30(%rsp)
addq $0x40, %rsi
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x16db0
movq 0x38(%rsp), %rdi
callq 0x16dd0
jmp 0x4773d
leaq 0x78(%rsp), %rdi
callq 0x234b0
movl $0x0, 0x74(%rsp)
movq 0x30(%r... | yangwanyuan[P]HLKVDS/src/SegmentManager.cc |
hlkvds::Status::Status(hlkvds::Status::Code, char const*) | Status::Status(Code _code, const char* msg) :
code_(_code) {
uint32_t size = strlen(msg);
char* const result = new char[size + 1];
memcpy(result, msg, size);
result[size] = '\0';
state_ = result;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rdi
callq 0x81b0
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x8040
movq %rax, 0x1... | yangwanyuan[P]HLKVDS/src/Status.cc |
hlkvds::Status::ToString[abi:cxx11]() const | std::string Status::ToString() const {
char tmp[30];
const char* type;
switch (code_) {
case kOk:
return "OK";
case kNotFound:
type = "NotFound: ";
break;
case kCorruption:
type = "Corruption: ";
break;
c... | subq $0x98, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
movl (%rax), %eax
movq %rax, 0x38(%rsp)
subq $0x9, %rax
ja 0x49291
movq 0x38(%rsp), %rax
leaq 0xb112(%rip), %rcx # 0x542c0
movslq (%rcx,%rax,4), %rax
... | yangwanyuan[P]HLKVDS/src/Status.cc |
hlkvds::SuperBlockManager::Get(char*, unsigned long) | bool SuperBlockManager::Get(char* buff, uint64_t length) {
if (length != SuperBlockManager::SuperBlockSizeOnDevice()) {
return false;
}
memcpy((void *)buff, (const void*)&sb_, SuperBlockManager::SizeOfDBSuperBlock());
uint64_t reserved_region_length = SuperBlockManager::ReservedRegionLength();
... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x117e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
je 0x49490
movb $0x0, 0x57(%rsp)
jmp 0x494f7
movq 0x40(%rsp), %rax
movq %rax, 0x8... | yangwanyuan[P]HLKVDS/src/SuperBlockManager.cc |
hlkvds::SuperBlockManager::Set(char*, unsigned long) | bool SuperBlockManager::Set(char* buff, uint64_t length) {
if (length != SuperBlockManager::SuperBlockSizeOnDevice()) {
return false;
}
memcpy((void*)&sb_, (const void*)buff, SuperBlockManager::SizeOfDBSuperBlock());
uint64_t reserved_region_length = SuperBlockManager::ReservedRegionLength();
... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x117e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
je 0x49550
movb $0x0, 0x57(%rsp)
jmp 0x495b7
movq 0x40(%rsp), %rax
movq %rax, 0x8... | yangwanyuan[P]HLKVDS/src/SuperBlockManager.cc |
hlkvds::SuperBlockManager::SetSuperBlock(hlkvds::DBSuperBlock&) | void SuperBlockManager::SetSuperBlock(DBSuperBlock& sb) {
std::lock_guard<std::mutex> l(mtx_);
sb_.magic_number = sb.magic_number;
sb_.index_ht_size = sb.index_ht_size;
sb_.index_region_offset = sb.index_region_offset;
sb_.index_region_length = sb.index_region_length;
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x50, %rsi
leaq 0x10(%rsp), %rdi
callq 0xb5f0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rcx... | yangwanyuan[P]HLKVDS/src/SuperBlockManager.cc |
hlkvds::SuperBlockManager::SetReservedContent(char*, unsigned long) | bool SuperBlockManager::SetReservedContent(char* content, uint64_t length) {
std::lock_guard<std::mutex> l(mtx_);
if (length != SuperBlockManager::ReservedRegionLength()) {
return false;
}
memcpy((void*)resCont_, (const void*)content, length);
return true;
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x50, %rsi
leaq 0x30(%rsp), %rdi
callq 0xb5f0
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x116c0
movq %rax, 0x18(%rsp)
jmp 0x49801
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %... | yangwanyuan[P]HLKVDS/src/SuperBlockManager.cc |
hlkvds::SuperBlockManager::GetReservedContent(char*, unsigned long) | bool SuperBlockManager::GetReservedContent(char* content, uint64_t length) {
std::lock_guard<std::mutex> l(mtx_);
if (length != SuperBlockManager::ReservedRegionLength()) {
return false;
}
memcpy((void*)content,(const void*)resCont_, length);
return true;
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x50, %rsi
leaq 0x30(%rsp), %rdi
callq 0xb5f0
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x116c0
movq %rax, 0x18(%rsp)
jmp 0x498c1
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %... | yangwanyuan[P]HLKVDS/src/SuperBlockManager.cc |
hlkvds::FastTier::deleteAllSegments() | void FastTier::deleteAllSegments() {
delete mig_;
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();
segMtxVe... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x1e0(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x49ce9
movq 0x20(%rsp), %rdi
callq 0x36290
movq 0x20(%rsp), %rdi
callq 0x84b0
movq 0x18(%rsp), %rsi
addq $0x128, %rsi # imm = 0x128
leaq 0x50(%rsp), %rdi
callq 0... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::CreateAllSegments() | void FastTier::CreateAllSegments() {
std::unique_lock<std::mutex> lck_seg_map(segMapMtx_);
for (int i = 0; i < shardsNum_; i++) {
SegForReq * seg = new SegForReq(vol_, idxMgr_, options_.expired_time);
segMap_.insert(make_pair(i, seg));
std::mutex *seg_mtx = new mutex();
segMtxVe... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rsi
movq %rsi, 0x40(%rsp)
addq $0x128, %rsi # imm = 0x128
leaq 0x90(%rsp), %rdi
callq 0x15a10
movl $0x0, 0x8c(%rsp)
movq 0x40(%rsp), %rcx
movl 0x8c(%rsp), %eax
cmpl 0x124(%rcx), %eax
jge 0x49fa5
movl $0xd8, %edi
callq 0x84f0
movq %rax, 0x38(%rsp)
jmp 0... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::StartThds() | void FastTier::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_stop_.store(f... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x8c(%rsp)
movq 0x28(%rsp), %rcx
movl 0x8c(%rsp), %eax
cmpl 0x124(%rcx), %eax
jge 0x4a0fb
movl $0xd8, %edi
callq 0x84f0
movq 0x28(%rsp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movl $0x1, %edx
callq 0x4e990
... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::SegTimeoutThdEntry() | void FastTier::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::unique_lock<std:... | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq 0xe0(%rsp), %rsi
movq %rsi, 0x58(%rsp)
addq $0x128, %rsi # imm = 0x128
leaq 0xd0(%rsp), %rdi
callq 0x16db0
movq 0x58(%rsp), %rdi
addq $0x218, %rdi # imm = 0x218
callq 0x16f80
xorb $-0x1, %al
testb $0x1, %al
jne 0x4a29c
jmp 0x4a562
movl $0x0, 0xc8(%rsp)
m... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::MigrationThdEntry() | void FastTier::MigrationThdEntry() {
__DEBUG("Migration thread start!!");
while (!migrationT_stop_) {
uint32_t free_seg_num = vol_->GetTotalFreeSegs();
uint32_t total_seg_num = vol_->GetNumberOfSeg();
uint32_t used_seg_num = total_seg_num - free_seg_num;
double util_rate = (doub... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x228, %rdi # imm = 0x228
callq 0x16f80
xorb $-0x1, %al
testb $0x1, %al
jne 0x4a5cf
jmp 0x4a678
movq 0x8(%rsp), %rax
movq 0x1d8(%rax), %rdi
callq 0x510f0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::StopThds() | void FastTier::StopThds() {
//vol_->StopThds();
migrationT_stop_.store(true);
migrationT_.join();
segTimeoutT_stop_.store(true);
segTimeoutT_.join();
for (int i = 0; i < shardsNum_; i++) {
ReqsMergeWQ *req_wq = reqWQVec_[i];
req_wq->Stop();
delete req_wq;
}
req... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x228, %rdi # imm = 0x228
movl $0x1, %esi
movl $0x5, %edx
callq 0x15f20
movq 0x18(%rsp), %rdi
addq $0x220, %rdi # imm = 0x220
callq 0x87f0
movq 0x18(%rsp), %rdi
addq $0x218, %rdi # imm = 0x218
movl ... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::writeDataImmediately(hlkvds::KVSlice&) | Status FastTier::writeDataImmediately(KVSlice& slice){
uint32_t seg_id = 0;
bool ret = false;
ret = allocSegment(seg_id);
if (!ret) {
__ERROR("Cann't get a new Empty Segment.\n");
return Status::Aborted("Can't allocate a Empty Segment.");
}
SegLatencyFriendly *seg = new SegLate... | subq $0x78, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movl $0x0, 0x5c(%rsp)
movb $0x0, 0x5b(%rsp)
leaq 0x5c(%rsp), %rsi
callq 0x4b110
andb $0x1, %al
movb %al, 0x5b(%rsp)
testb $0x1, 0x5b(... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::WriteBatchData(hlkvds::WriteBatch*) | Status FastTier::WriteBatchData(WriteBatch *batch) {
uint32_t seg_id = 0;
bool ret = false;
ret = allocSegment(seg_id);
if (!ret) {
__ERROR("Cann't get a new Empty Segment.\n");
return Status::Aborted("Can't allocate a Empty Segment.");
}
SegForSlice *seg = new SegForSlice(vol_... | 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)
movl $0x0, 0x9c(%rsp)
movb $0x0, 0x9b(%rsp)
leaq 0x9c(%rsp), %rsi
callq 0x4b110
andb $0x1, %al
movb %al, 0x9b(%rsp)
testb $0x1, 0x9b(... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::allocSegment(unsigned int&) | bool FastTier::allocSegment(uint32_t &seg_id) {
std::lock_guard <std::mutex> l(allocMtx_);
uint32_t mt_vol_num = mt_->GetVolumeNum();
while (!vol_->Alloc(seg_id)) {
__DEBUG("cant't alloc segment, need migrate, free = %d, used = %d", vol_->GetTotalFreeSegs(), vol_->GetTotalUsedSegs());
if (m... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x18(%rsp)
addq $0x198, %rsi # imm = 0x198
leaq 0x48(%rsp), %rdi
callq 0xb5f0
movq 0x18(%rsp), %rax
movq 0x1e8(%rax), %rdi
callq 0x4ec00
movl %eax, 0x24(%rsp)
jmp 0x4b150
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::ReadData(hlkvds::KVSlice&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | Status FastTier::ReadData(KVSlice &slice, std::string &data) {
HashEntry *entry;
entry = &slice.GetHashEntry();
uint64_t data_offset = 0;
if (!vol_->CalcDataOffsetPhyFromEntry(entry, data_offset)) {
return Status::Aborted("Calculate data offset failed.");
}
uint16_t data_len = entry->G... | subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rdi
callq 0x116b0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq $0x0, 0x48... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::GetSBReservedContent(char*, unsigned long) | bool FastTier::GetSBReservedContent(char* buf, uint64_t length) {
if (length != sizeof(MultiTierDS_SB_Reserved_FastTier)) {
return false;
}
sbResFastTier_.cur_seg_id = vol_->GetCurSegId();
memcpy((void*)buf, (const void*)&sbResFastTier_, length);
__DEBUG("MultiTierDS_SB_Reserved_FastTier: ... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x10c, 0x8(%rsp) # imm = 0x10C
je 0x4b43e
movb $0x0, 0x27(%rsp)
jmp 0x4b470
movq (%rsp), %rax
movq 0x1d8(%rax), %rdi
callq 0x51070
movq (%rsp), %rsi
movl %eax, 0x120(%rsi)
movq 0x10(%rsp... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::SetSBReservedContent(char*, unsigned long) | bool FastTier::SetSBReservedContent(char* buf, uint64_t length) {
if (length != sizeof(MultiTierDS_SB_Reserved_FastTier)) {
return false;
}
memcpy((void*)&sbResFastTier_, (const void*)buf, length);
__DEBUG("MultiTierDS_SB_Reserved_FastTier: segment_size = %d, dev_path = %s, segment_num = %d, cu... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x10c, 0x8(%rsp) # imm = 0x10C
je 0x4b4ae
movb $0x0, 0x27(%rsp)
jmp 0x4b4ca
movq (%rsp), %rdi
addq $0x18, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x8410
movb $0x1, 0x27(%rs... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::CreateVolume(std::vector<hlkvds::BlockDevice*, std::allocator<hlkvds::BlockDevice*>>&, unsigned long, unsigned int) | bool FastTier::CreateVolume(std::vector<BlockDevice*> &bd_vec, uint64_t sst_offset, uint32_t medium_tier_total_seg_num) {
segSize_ = options_.segment_size;
uint32_t align_bit = log2(ALIGNED_SIZE);
if (segSize_ != (segSize_ >> align_bit) << align_bit) {
__ERROR("FastTier Segment Size is not page ali... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movl %ecx, 0x74(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq (%rax), %rcx
movl 0x44(%rcx), %ecx
movl %ecx, 0x1d0(%rax)
movl $0x1000, %edi # imm = 0x1000
callq 0x16680
movq 0x38(%rsp), %rcx
cvttsd2si %xmm0, %rax
movl %... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::initSBReservedContentForCreate() | void FastTier::initSBReservedContentForCreate() {
sbResFastTier_.segment_size = segSize_;
string dev_path = vol_->GetDevicePath();
memcpy((void*)&sbResFastTier_.dev_path, (const void*)dev_path.c_str(), dev_path.size());
sbResFastTier_.segment_num = segNum_;
sbResFastTier_.cur_seg_id = vol_->GetCurS... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x1d0(%rax), %ecx
movl %ecx, 0x18(%rax)
movq 0x1d8(%rax), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x51090
movq (%rsp), %rdi
movq 0x18(%rsp), %rax
addq $0x1c, %rax
movq %rax, 0x8(%rsp)
callq 0x8180
movq (%rsp), %rdi
movq %... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::OpenVolume(std::vector<hlkvds::BlockDevice*, std::allocator<hlkvds::BlockDevice*>>&) | bool FastTier::OpenVolume(std::vector<BlockDevice*> &bd_vec) {
segSize_ = sbResFastTier_.segment_size;
segNum_ = sbResFastTier_.segment_num;
maxValueLen_ = segSize_ - SegBase::SizeOfSegOnDisk() - IndexManager::SizeOfHashEntryOnDisk();
sstLengthOnDisk_ = sbMgr_->GetSSTRegionLength();
if (!verifyTopo... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x18(%rax), %ecx
movl %ecx, 0x1d0(%rax)
movl 0x11c(%rax), %ecx
movl %ecx, 0x1d4(%rax)
movl 0x1d0(%rax), %eax
movq %rax, 0x30(%rsp)
callq 0x166a0
movq %rax, %rcx
movq 0x30(%rsp), %rax
subq %rcx, %rax
movq %rax, ... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::verifyTopology(std::vector<hlkvds::BlockDevice*, std::allocator<hlkvds::BlockDevice*>>&) | bool FastTier::verifyTopology(std::vector<BlockDevice*> &bd_vec) {
string record_path = string(sbResFastTier_.dev_path);
string device_path = bd_vec[0]->GetDevicePath();
if (record_path != device_path) {
__ERROR("record_path: %s, device_path:%s ", record_path.c_str(), device_path.c_str());
r... | subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x98(%rsp), %rax
addq $0x1c, %rax
movq %rax, 0x20(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8830
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x8680
jmp 0x4bafd
leaq 0x6f(%rsp), %rdi
callq 0x8540
movq 0x90(%rsp)... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::GetKeyByHashEntry[abi:cxx11](hlkvds::HashEntry*) | std::string FastTier::GetKeyByHashEntry(HashEntry *entry) {
uint64_t key_offset = 0;
if (!vol_->CalcKeyOffsetPhyFromEntry(entry, key_offset)) {
return "";
}
__DEBUG("key offset: %lu",key_offset);
uint16_t key_len = entry->GetKeySize();
char *mkey = new char[key_len+1];
if (!vol_->Re... | subq $0xa8, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x58(%rsp)
movq $0x0, 0x88(%rsp)
movq 0x1d8(%rax), %rdi
movq 0x90(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x513b0
testb $0x1, %al
jne 0x4beb1
le... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::GetValueByHashEntry[abi:cxx11](hlkvds::HashEntry*) | std::string FastTier::GetValueByHashEntry(HashEntry *entry) {
uint64_t data_offset = 0;
if (!vol_->CalcDataOffsetPhyFromEntry(entry, data_offset)) {
return "";
}
__DEBUG("data offset: %lu",data_offset);
uint16_t data_len = entry->GetDataSize();
if ( data_len ==0 ) {
return "";
... | subq $0xa8, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x58(%rsp)
movq $0x0, 0x88(%rsp)
movq 0x1d8(%rax), %rdi
movq 0x90(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x51320
testb $0x1, %al
jne 0x4c181
le... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::PickVolForMigrate() | uint32_t MediumTier::PickVolForMigrate() {
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 $0x80, %rsi
leaq 0x18(%rsp), %rdi
callq 0xb5f0
movq 0x10(%rsp), %rcx
movl 0x78(%rcx), %eax
movl 0x40(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4c534
movq 0x10(%rsp), %rax
movl $0x0, 0x78(%rax)
jmp 0x4c542
movq 0x10(%rsp), %r... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::ReqMerge(hlkvds::Request*) | void FastTier::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 = segMap_[shard_id... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x16da0
movq 0x58(%rsp), %rsi
movl %eax, 0xe4(%rsp)
addq $0x128, %rsi # imm = 0x128
leaq 0xd0(%rsp), %rdi
callq 0x16db0
movq 0x58(%rsp), %rdi
addq $0x180, %rdi # imm... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::FastTier::SegWrite(hlkvds::SegForReq*) | void FastTier::SegWrite(SegForReq *seg) {
uint32_t seg_id = 0;
bool ret = false;
ret = allocSegment(seg_id);
if (!ret) {
__ERROR("Cann't get a new Empty Segment.\n");
seg->Notify(ret);
return ;
}
uint32_t free_size = seg->GetFreeSize();
seg->SetSegId(seg_id);
re... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movb $0x0, 0x23(%rsp)
leaq 0x24(%rsp), %rsi
callq 0x4b110
andb $0x1, %al
movb %al, 0x23(%rsp)
testb $0x1, 0x23(%rsp)
jne 0x4c965
jmp 0x4c8e2
movq 0x246ef(%rip), %rax # 0x70fd8
movq (%rax), ... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::deleteAllVolume() | void MediumTier::deleteAllVolume() {
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 $0x48, %rdi
callq 0x16af0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
callq 0x16b40
movq %rax, 0x38(%rsp)
leaq 0x... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::printDeviceTopologyInfo() | void MediumTier::printDeviceTopologyInfo() {
__INFO( "\n\t Medium Tier Infomation:\n"
"\t Medium Tier Seg Size : %d\n"
"\t Medium Tier Vol Num : %d",
sbResMediumTierHeader_.segment_size, sbResMediumTierHeader_.volume_num);
for (uint32_t i = 0 ; i < volNum_... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x2432e(%rip), %rax # 0x70fd8
movq (%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x8480
movq 0x28(%rsp), %rdi
movq %rax, %rdx
leaq 0x56f6(%rip), %rsi # 0x523bc
leaq 0x570f(%rip), %rcx # 0x523dc
leaq 0x780e(%rip), %r8 ... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::ManualGC() | void MediumTier::ManualGC() {
map<int, Volume *>::iterator iter;
for (iter = volMap_.begin(); iter != volMap_.end(); ) {
Volume *vol = iter->second;
vol->FullGC();
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x16ad0
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x16af0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x16b40
movq %rax, 0x18(%rsp)
leaq 0x28(... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::GetSBReservedContent(char*, unsigned long) | bool MediumTier::GetSBReservedContent(char* buf, uint64_t length) {
uint32_t except_length = sizeof(MultiTierDS_SB_Reserved_MediumTier_Header) +
volNum_ * sizeof(MultiTierDS_SB_Reserved_MediumTier_Content);
if (length != except_length) {
return false;
}
updateAllVolS... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x40(%rax), %eax
imulq $0x108, %rax, %rax # imm = 0x108
addq $0x8, %rax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
cmpq %rcx, %rax
je 0x4d137
movb $0x0, 0x57(%rs... | yangwanyuan[P]HLKVDS/src/Tier.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.