Re: Adding compression support for bluestore.

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 





On 01.04.2016 0:56, Sage Weil wrote:
How about this:

// in the onode:
map<uint64_t, bluestore_lextent_t> data_map;
map<int, bluestore_blob_t> blob_map;

// in the enode
map<int, bluestore_blob_t> blob_map;

struct bluestore_lextent_t {
   enum {
     FLAG_SHARED = 1,        ///< pextent lives in enode
   };

   uint64_t logical_length;  ///< length of logical bytes we represent
No need for that field - x_len is exactly the same.
   uint32_t pextent_id;      ///< id of pextent in onode or enode
blob_id as Allen already mentioned.

   uint32_t x_off, x_len;    ///< relative portion of pextent with our data
   uint32_t flags;           ///< FLAG_*
};

struct bluestore_pextent_t {
   uint64_t offset;          ///< offset on disk
   uint64_t length;          ///< length on disk
};

struct bluestore_blob_t {
   enum {
     CSUM_XXHASH32 = 1,
     CSUM_XXHASH64 = 2,
     CSUM_CRC32C = 3,
     CSUM_CRC16 = 4,
   };
   enum {
     FLAG_IMMUTABLE = 1,     ///< no overwrites allowed
     FLAG_COMPRESSED = 2,    ///< extent is compressed; alg is in first byte of data
   };
   enum {
     COMP_ZLIB = 1,
     COMP_SNAPPY = 2,
     COMP_LZO = 3,
   };

   vector<bluestore_pextent_t> extents;  ///< extents on disk
Major reasons to have a set of pextents instead of a single one are as follows, right? 1) To be able to handle the case Allen pointed out when we are unable to allocate contiguous region during the writing. 2) To be able to deallocate the blob partially, e.g. when it's partially occluded.

   uint32_t logical_length;              ///< uncompressed length
   uint32_t flags;                       ///< FLAG_*
   uint8_t csum_type;                    ///< CSUM_*
   uint8_t csum_block_order;
   uint16_t num_refs;               ///< reference count (always 1 when in onode)
   vector<char> csum_data;          ///< opaque vector of csum data

   uint32_t get_ondisk_length() const {
     uint32_t len = 0;
     for (auto &p : extentes) {
       len += p.length;
     }
     return len;
   }

   uint32_t get_csum_block_size() const {
     return 1 << csum_block_order;
   }
Shouldn't we try to maintain single pextent size equal (or aligned) to this one?

   size_t get_csum_value_size() const {
     switch (csum_type) {
     case CSUM_XXHASH32: return 4;
     case CSUM_XXHASH64: return 8;
     case CSUM_CRC32C: return 4;
     case CSUM_CRC16: return 2;
     default: return 0;
     }
   }

   // assert (ondisk_length / csum_block_size) * csum_value_size ==
   // csum_data.length()
};

--
To unsubscribe from this list: send the line "unsubscribe ceph-devel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html



[Index of Archives]     [CEPH Users]     [Ceph Large]     [Information on CEPH]     [Linux BTRFS]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]
  Powered by Linux