TheCloud/dwarfs
1
0
Fork 0
mirror of https://github.com/mhx/dwarfs.git synced 2025-09-17 00:10:03 -04:00
Code Issues Packages Projects Releases Wiki Activity

folly::Range -> std::span in filesystem_writer

Browse Source
This commit is contained in:
Marcus Holland-Moritz 2023-05-26 18:27:04 +02:00
parent 32314eef34
commit 5b075a563a
2 changed files with 25 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
include/dwarfs/filesystem_writer.h
View File

@ -25,10 +25,9 @@
#include <cstdint>
#include <memory>
#include <ostream>
#include <span>
#include <utility>
#include <folly/Range.h>
#include "dwarfs/fstypes.h"
#include "dwarfs/options.h"
#include "dwarfs/worker_group.h"
@ -56,7 +55,9 @@ class filesystem_writer {
filesystem_writer_options const& options,
std::istream* header = nullptr);
void copy_header(folly::ByteRange header) { impl_->copy_header(header); }
void copy_header(std::span<uint8_t const> header) {
impl_->copy_header(header);
}
void write_block(std::shared_ptr<block_data>&& data) {
impl_->write_block(std::move(data));
@ -71,7 +72,7 @@ class filesystem_writer {
}
void write_compressed_section(section_type type, compression_type compression,
folly::ByteRange data) {
std::span<uint8_t const> data) {
impl_->write_compressed_section(type, compression, data);
}
@ -85,14 +86,14 @@ class filesystem_writer {
public:
virtual ~impl() = default;
virtual void copy_header(folly::ByteRange header) = 0;
virtual void copy_header(std::span<uint8_t const> header) = 0;
virtual void write_block(std::shared_ptr<block_data>&& data) = 0;
virtual void
write_metadata_v2_schema(std::shared_ptr<block_data>&& data) = 0;
virtual void write_metadata_v2(std::shared_ptr<block_data>&& data) = 0;
virtual void
write_compressed_section(section_type type, compression_type compression,
folly::ByteRange data) = 0;
std::span<uint8_t const> data) = 0;
virtual void flush() = 0;
virtual size_t size() const = 0;
virtual int queue_fill() const = 0;

36
src/dwarfs/filesystem_writer.cpp
View File

@ -28,7 +28,6 @@
#include <mutex>
#include <thread>
#include <folly/Range.h>
#include <folly/system/ThreadName.h>
#include "dwarfs/block_compressor.h"
@ -51,13 +50,13 @@ class fsblock {
std::shared_ptr<block_data>&& data, uint32_t number);
fsblock(section_type type, compression_type compression,
folly::ByteRange data, uint32_t number);
std::span<uint8_t const> data, uint32_t number);
void compress(worker_group& wg) { impl_->compress(wg); }
void wait_until_compressed() { impl_->wait_until_compressed(); }
section_type type() const { return impl_->type(); }
compression_type compression() const { return impl_->compression(); }
folly::ByteRange data() const { return impl_->data(); }
std::span<uint8_t const> data() const { return impl_->data(); }
size_t uncompressed_size() const { return impl_->uncompressed_size(); }
size_t size() const { return impl_->size(); }
uint32_t number() const { return impl_->number(); }
@ -71,7 +70,7 @@ class fsblock {
virtual void wait_until_compressed() = 0;
virtual section_type type() const = 0;
virtual compression_type compression() const = 0;
virtual folly::ByteRange data() const = 0;
virtual std::span<uint8_t const> data() const = 0;
virtual size_t uncompressed_size() const = 0;
virtual size_t size() const = 0;
virtual uint32_t number() const = 0;
@ -124,7 +123,7 @@ class raw_fsblock : public fsblock::impl {
compression_type compression() const override { return comp_type_; }
folly::ByteRange data() const override { return data_->vec(); }
std::span<uint8_t const> data() const override { return data_->vec(); }
size_t uncompressed_size() const override { return uncompressed_size_; }
@ -152,7 +151,7 @@ class raw_fsblock : public fsblock::impl {
class compressed_fsblock : public fsblock::impl {
public:
compressed_fsblock(section_type type, compression_type compression,
folly::ByteRange range, uint32_t number)
std::span<uint8_t const> range, uint32_t number)
: type_{type}
, compression_{compression}
, range_{range}
@ -173,7 +172,7 @@ class compressed_fsblock : public fsblock::impl {
section_type type() const override { return type_; }
compression_type compression() const override { return compression_; }
folly::ByteRange data() const override { return range_; }
std::span<uint8_t const> data() const override { return range_; }
size_t uncompressed_size() const override { return range_.size(); }
size_t size() const override { return range_.size(); }
@ -185,7 +184,7 @@ class compressed_fsblock : public fsblock::impl {
private:
section_type const type_;
compression_type const compression_;
folly::ByteRange range_;
std::span<uint8_t const> range_;
std::future<void> future_;
uint32_t const number_;
section_header_v2 header_;
@ -196,7 +195,7 @@ fsblock::fsblock(section_type type, block_compressor const& bc,
: impl_(std::make_unique<raw_fsblock>(type, bc, std::move(data), number)) {}
fsblock::fsblock(section_type type, compression_type compression,
folly::ByteRange data, uint32_t number)
std::span<uint8_t const> data, uint32_t number)
: impl_(std::make_unique<compressed_fsblock>(type, compression, data,
number)) {}
@ -236,12 +235,12 @@ class filesystem_writer_ final : public filesystem_writer::impl {
std::istream* header);
~filesystem_writer_() noexcept override;
void copy_header(folly::ByteRange header) override;
void copy_header(std::span<uint8_t const> header) override;
void write_block(std::shared_ptr<block_data>&& data) override;
void write_metadata_v2_schema(std::shared_ptr<block_data>&& data) override;
void write_metadata_v2(std::shared_ptr<block_data>&& data) override;
void write_compressed_section(section_type type, compression_type compression,
folly::ByteRange data) override;
std::span<uint8_t const> data) override;
void flush() override;
size_t size() const override { return os_.tellp(); }
int queue_fill() const override { return static_cast<int>(wg_.queue_size()); }
@ -253,7 +252,7 @@ class filesystem_writer_ final : public filesystem_writer::impl {
void write(const char* data, size_t size);
template <typename T>
void write(const T& obj);
void write(folly::ByteRange range);
void write(std::span<uint8_t const> range);
void writer_thread();
void push_section_index(section_type type);
void write_section_index();
@ -377,7 +376,7 @@ void filesystem_writer_<LoggerPolicy>::write(const T& obj) {
}
template <typename LoggerPolicy>
void filesystem_writer_<LoggerPolicy>::write(folly::ByteRange range) {
void filesystem_writer_<LoggerPolicy>::write(std::span<uint8_t const> range) {
write(reinterpret_cast<const char*>(range.data()), range.size());
}
@ -422,7 +421,8 @@ void filesystem_writer_<LoggerPolicy>::write_section(
template <typename LoggerPolicy>
void filesystem_writer_<LoggerPolicy>::write_compressed_section(
section_type type, compression_type compression, folly::ByteRange data) {
section_type type, compression_type compression,
std::span<uint8_t const> data) {
auto fsb =
std::make_unique<fsblock>(type, compression, data, section_number_++);
@ -437,7 +437,8 @@ void filesystem_writer_<LoggerPolicy>::write_compressed_section(
}
template <typename LoggerPolicy>
void filesystem_writer_<LoggerPolicy>::copy_header(folly::ByteRange header) {
void filesystem_writer_<LoggerPolicy>::copy_header(
std::span<uint8_t const> header) {
if (!options_.remove_header) {
if (header_) {
LOG_WARN << "replacing old header";
@ -496,9 +497,8 @@ void filesystem_writer_<LoggerPolicy>::push_section_index(section_type type) {
template <typename LoggerPolicy>
void filesystem_writer_<LoggerPolicy>::write_section_index() {
push_section_index(section_type::SECTION_INDEX);
auto data =
folly::ByteRange(reinterpret_cast<uint8_t*>(section_index_.data()),
sizeof(section_index_[0]) * section_index_.size());
auto data = std::span(reinterpret_cast<uint8_t*>(section_index_.data()),
sizeof(section_index_[0]) * section_index_.size());
auto fsb = fsblock(section_type::SECTION_INDEX, compression_type::NONE, data,
section_number_++);