Commit 209af1e9 authored by Tommaso Tocci's avatar Tommaso Tocci Committed by Marc Vef
Browse files

Simplify UpdateSize Operand 

The UpdateSizeOperand has been renamed IncreaseSizeOperand.

The operand was using three parameters size,offset and append_flag.

Since we only need the (size + offset) sum in order to apply the
operand, the offset field has been removed.
parent 41221c82

ifs/include/daemon/db/merge.hpp

+3 −4
Original line number Diff line number Diff line
@@ -8,18 +8,17 @@ 
namespace rdb = rocksdb;





class UpdateSizeOperand {

class IncreaseSizeOperand {

    public:

        const static char separator;

        const static char true_char;

        const static char false_char;



        size_t size;

        off64_t offset;

        bool append;



        UpdateSizeOperand(const size_t size, const off64_t offset, const bool append);

        UpdateSizeOperand(const std::string& serialized_op);

        IncreaseSizeOperand(const size_t size, const bool append);

        IncreaseSizeOperand(const std::string& serialized_op);



        std::string serialize() const;

};

ifs/src/daemon/db/db_ops.cpp

+1 −1
Original line number Diff line number Diff line
@@ -52,7 +52,7 @@ bool db_update_metadentry(const std::string& old_key, const std::string& new_key 
bool db_update_metadentry_size(const std::string& key,

        size_t size, off64_t offset, bool append) {

    auto db = ADAFS_DATA->rdb();

    auto uop = UpdateSizeOperand(size, offset, append);

    auto uop = IncreaseSizeOperand(offset + size, append);

    auto s = db->Merge(ADAFS_DATA->rdb_write_options(), key, uop.serialize());

    if(!s.ok()){

        ADAFS_DATA->spdlogger()->error("Failed to update metadentry size. RDB error: [{}]", s.ToString());

ifs/src/daemon/db/merge.cpp

+10 −21
Original line number Diff line number Diff line 
#include <daemon/db/merge.hpp>





const char UpdateSizeOperand::separator = ',';

const char UpdateSizeOperand::true_char = 't';

const char UpdateSizeOperand::false_char = 'f';

const char IncreaseSizeOperand::separator = ',';

const char IncreaseSizeOperand::true_char = 't';

const char IncreaseSizeOperand::false_char = 'f';



UpdateSizeOperand::UpdateSizeOperand(const size_t size,

        const off64_t offset,

        const bool append): size(size), offset(offset), append(append) {}

IncreaseSizeOperand::IncreaseSizeOperand(const size_t size, const bool append):

    size(size), append(append) {}



UpdateSizeOperand::UpdateSizeOperand(const std::string& serialized_op){

IncreaseSizeOperand::IncreaseSizeOperand(const std::string& serialized_op){

    size_t chrs_parsed = 0;

    size_t read = 0;
@@ -18,11 +17,6 @@ UpdateSizeOperand::UpdateSizeOperand(const std::string& serialized_op){ 
    chrs_parsed += read + 1;

    assert(serialized_op.at(chrs_parsed - 1) == separator);



    //Parse offset

    offset = std::stoll(&serialized_op.at(chrs_parsed), &read);

    chrs_parsed += read + 1;

    assert(serialized_op.at(chrs_parsed - 1) == separator);



    //Parse append flag

    assert(serialized_op.at(chrs_parsed) == false_char ||

           serialized_op.at(chrs_parsed) == true_char);
@@ -31,12 +25,10 @@ UpdateSizeOperand::UpdateSizeOperand(const std::string& serialized_op){ 
    assert(chrs_parsed + 1 == serialized_op.size());

}



std::string UpdateSizeOperand::serialize() const {

std::string IncreaseSizeOperand::serialize() const {

    std::string s;

    s += std::to_string(size);

    s += this->separator;

    s += std::to_string(offset);

    s += this->separator;

    s += (append == false)? false_char : true_char;

    return s;

}
@@ -54,19 +46,16 @@ bool MetadataMergeOperator::FullMergeV2( 
        return false;

    }





    Metadata md{merge_in.key.ToString(), merge_in.existing_value->ToString()};

    size_t fsize = md.size();



    for(const auto& operand: merge_in.operand_list){

        auto op = UpdateSizeOperand(operand.ToString());

        auto op = IncreaseSizeOperand(operand.ToString());

        if(op.append){

            //append mode, just increment file

            fsize += op.size;

        } else if((op.offset + op.size) > fsize){

            //not append: increment only if we beyond

            //current file size

            fsize = op.offset + op.size;

        } else {

            fsize = std::max(op.size, fsize);

        }

    }