ClickHouse/dbms/IO/ReadBufferAIO.cpp
Ivan 97f2a2213e
Move all folders inside /dbms one level up (#9974)
* Move some code outside dbms/src folder
* Fix paths
2020-04-02 02:51:21 +03:00

312 lines
9.1 KiB
C++

#if defined(__linux__) || defined(__FreeBSD__)
#include <IO/ReadBufferAIO.h>
#include <IO/AIOContextPool.h>
#include <Common/ProfileEvents.h>
#include <Common/Stopwatch.h>
#include <Core/Defines.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <optional>
namespace ProfileEvents
{
extern const Event FileOpen;
extern const Event ReadBufferAIORead;
extern const Event ReadBufferAIOReadBytes;
}
namespace CurrentMetrics
{
extern const Metric Read;
}
namespace DB
{
namespace ErrorCodes
{
extern const int FILE_DOESNT_EXIST;
extern const int CANNOT_OPEN_FILE;
extern const int LOGICAL_ERROR;
extern const int ARGUMENT_OUT_OF_BOUND;
extern const int AIO_READ_ERROR;
}
/// Note: an additional page is allocated that will contain the data that
/// does not fit into the main buffer.
ReadBufferAIO::ReadBufferAIO(const std::string & filename_, size_t buffer_size_, int flags_, char * existing_memory_)
: ReadBufferFromFileBase(buffer_size_ + DEFAULT_AIO_FILE_BLOCK_SIZE, existing_memory_, DEFAULT_AIO_FILE_BLOCK_SIZE),
fill_buffer(BufferWithOwnMemory<ReadBuffer>(internalBuffer().size(), nullptr, DEFAULT_AIO_FILE_BLOCK_SIZE)),
filename(filename_)
{
ProfileEvents::increment(ProfileEvents::FileOpen);
int open_flags = (flags_ == -1) ? O_RDONLY : flags_;
open_flags |= O_DIRECT;
open_flags |= O_CLOEXEC;
fd = ::open(filename.c_str(), open_flags);
if (fd == -1)
{
auto error_code = (errno == ENOENT) ? ErrorCodes::FILE_DOESNT_EXIST : ErrorCodes::CANNOT_OPEN_FILE;
throwFromErrnoWithPath("Cannot open file " + filename, filename, error_code);
}
}
ReadBufferAIO::~ReadBufferAIO()
{
if (!aio_failed)
{
try
{
(void) waitForAIOCompletion();
}
catch (...)
{
tryLogCurrentException(__PRETTY_FUNCTION__);
}
}
if (fd != -1)
::close(fd);
}
void ReadBufferAIO::setMaxBytes(size_t max_bytes_read_)
{
if (is_started)
throw Exception("Illegal attempt to set the maximum number of bytes to read from file " + filename, ErrorCodes::LOGICAL_ERROR);
max_bytes_read = max_bytes_read_;
}
bool ReadBufferAIO::nextImpl()
{
/// If the end of the file has already been reached by calling this function,
/// then the current call is wrong.
if (is_eof)
return false;
std::optional<Stopwatch> watch;
if (profile_callback)
watch.emplace(clock_type);
if (!is_aio)
{
synchronousRead();
is_aio = true;
}
else
receive();
if (profile_callback)
{
ProfileInfo info;
info.bytes_requested = requested_byte_count;
info.bytes_read = bytes_read;
info.nanoseconds = watch->elapsed();
profile_callback(info);
}
is_started = true;
/// If the end of the file is just reached, do nothing else.
if (is_eof)
return bytes_read != 0;
/// Create an asynchronous request.
prepare();
#if defined(__FreeBSD__)
request.aio.aio_lio_opcode = LIO_READ;
request.aio.aio_fildes = fd;
request.aio.aio_buf = reinterpret_cast<volatile void *>(buffer_begin);
request.aio.aio_nbytes = region_aligned_size;
request.aio.aio_offset = region_aligned_begin;
#else
request.aio_lio_opcode = IOCB_CMD_PREAD;
request.aio_fildes = fd;
request.aio_buf = reinterpret_cast<UInt64>(buffer_begin);
request.aio_nbytes = region_aligned_size;
request.aio_offset = region_aligned_begin;
#endif
/// Send the request.
try
{
future_bytes_read = AIOContextPool::instance().post(request);
}
catch (...)
{
aio_failed = true;
throw;
}
is_pending_read = true;
return true;
}
off_t ReadBufferAIO::seek(off_t off, int whence)
{
off_t new_pos_in_file;
if (whence == SEEK_SET)
{
if (off < 0)
throw Exception("SEEK_SET underflow", ErrorCodes::ARGUMENT_OUT_OF_BOUND);
new_pos_in_file = off;
}
else if (whence == SEEK_CUR)
{
if (off >= 0)
{
if (off > (std::numeric_limits<off_t>::max() - getPosition()))
throw Exception("SEEK_CUR overflow", ErrorCodes::ARGUMENT_OUT_OF_BOUND);
}
else if (off < -getPosition())
throw Exception("SEEK_CUR underflow", ErrorCodes::ARGUMENT_OUT_OF_BOUND);
new_pos_in_file = getPosition() + off;
}
else
throw Exception("ReadBufferAIO::seek expects SEEK_SET or SEEK_CUR as whence", ErrorCodes::ARGUMENT_OUT_OF_BOUND);
if (new_pos_in_file != getPosition())
{
off_t first_read_pos_in_file = first_unread_pos_in_file - static_cast<off_t>(working_buffer.size());
if (hasPendingData() && (new_pos_in_file >= first_read_pos_in_file) && (new_pos_in_file <= first_unread_pos_in_file))
{
/// Moved, but remained within the buffer.
pos = working_buffer.begin() + (new_pos_in_file - first_read_pos_in_file);
}
else
{
/// Moved past the buffer.
pos = working_buffer.end();
first_unread_pos_in_file = new_pos_in_file;
/// If we go back, than it's not eof
is_eof = false;
/// We can not use the result of the current asynchronous request.
skip();
}
}
return new_pos_in_file;
}
void ReadBufferAIO::synchronousRead()
{
CurrentMetrics::Increment metric_increment_read{CurrentMetrics::Read};
prepare();
bytes_read = ::pread(fd, buffer_begin, region_aligned_size, region_aligned_begin);
ProfileEvents::increment(ProfileEvents::ReadBufferAIORead);
ProfileEvents::increment(ProfileEvents::ReadBufferAIOReadBytes, bytes_read);
finalize();
}
void ReadBufferAIO::receive()
{
if (!waitForAIOCompletion())
return;
finalize();
}
void ReadBufferAIO::skip()
{
if (!waitForAIOCompletion())
return;
is_aio = false;
/// @todo I presume this assignment is redundant since waitForAIOCompletion() performs a similar one
// bytes_read = future_bytes_read.get();
if ((bytes_read < 0) || (static_cast<size_t>(bytes_read) < region_left_padding))
throw Exception("Asynchronous read error on file " + filename, ErrorCodes::AIO_READ_ERROR);
}
bool ReadBufferAIO::waitForAIOCompletion()
{
if (is_eof || !is_pending_read)
return false;
CurrentMetrics::Increment metric_increment_read{CurrentMetrics::Read};
bytes_read = future_bytes_read.get();
is_pending_read = false;
ProfileEvents::increment(ProfileEvents::ReadBufferAIORead);
ProfileEvents::increment(ProfileEvents::ReadBufferAIOReadBytes, bytes_read);
return true;
}
void ReadBufferAIO::prepare()
{
requested_byte_count = std::min(fill_buffer.internalBuffer().size() - DEFAULT_AIO_FILE_BLOCK_SIZE, max_bytes_read);
/// Region of the disk from which we want to read data.
const off_t region_begin = first_unread_pos_in_file;
if ((requested_byte_count > static_cast<size_t>(std::numeric_limits<off_t>::max())) ||
(first_unread_pos_in_file > (std::numeric_limits<off_t>::max() - static_cast<off_t>(requested_byte_count))))
throw Exception("An overflow occurred during file operation", ErrorCodes::LOGICAL_ERROR);
const off_t region_end = first_unread_pos_in_file + requested_byte_count;
/// The aligned region of the disk from which we will read the data.
region_left_padding = region_begin % DEFAULT_AIO_FILE_BLOCK_SIZE;
const size_t region_right_padding = (DEFAULT_AIO_FILE_BLOCK_SIZE - (region_end % DEFAULT_AIO_FILE_BLOCK_SIZE)) % DEFAULT_AIO_FILE_BLOCK_SIZE;
region_aligned_begin = region_begin - region_left_padding;
if (region_end > (std::numeric_limits<off_t>::max() - static_cast<off_t>(region_right_padding)))
throw Exception("An overflow occurred during file operation", ErrorCodes::LOGICAL_ERROR);
const off_t region_aligned_end = region_end + region_right_padding;
region_aligned_size = region_aligned_end - region_aligned_begin;
buffer_begin = fill_buffer.internalBuffer().begin();
}
void ReadBufferAIO::finalize()
{
if ((bytes_read < 0) || (static_cast<size_t>(bytes_read) < region_left_padding))
throw Exception("Asynchronous read error on file " + filename, ErrorCodes::AIO_READ_ERROR);
/// Ignore redundant bytes on the left.
bytes_read -= region_left_padding;
/// Ignore redundant bytes on the right.
bytes_read = std::min(static_cast<off_t>(bytes_read), static_cast<off_t>(requested_byte_count));
if (bytes_read > 0)
fill_buffer.buffer().resize(region_left_padding + bytes_read);
if (static_cast<size_t>(bytes_read) < requested_byte_count)
is_eof = true;
if (first_unread_pos_in_file > (std::numeric_limits<off_t>::max() - bytes_read))
throw Exception("An overflow occurred during file operation", ErrorCodes::LOGICAL_ERROR);
first_unread_pos_in_file += bytes_read;
total_bytes_read += bytes_read;
working_buffer_offset = region_left_padding;
if (total_bytes_read == max_bytes_read)
is_eof = true;
/// Swap the main and duplicate buffers.
swap(fill_buffer);
}
}
#endif