![]() |
Disk ARchive 2.7.16
Full featured and portable backup and archiving tool
|
the cache class implements a fixed length read/write caching mechanism More...
#include <cache.hpp>
Inherits libdar::generic_file.
Public Member Functions | |
cache (generic_file &hidden, bool shift_mode, U_I size=102400) | |
cache (const cache &ref)=delete | |
cache (cache &&ref)=delete | |
cache & | operator= (const cache &ref)=delete |
cache & | operator= (cache &&ref)=delete |
void | change_to_read_write () |
virtual bool | skippable (skippability direction, const infinint &amount) override |
whether the implementation is able to skip | |
virtual bool | skip (const infinint &pos) override |
skip at the absolute position | |
virtual bool | skip_to_eof () override |
skip to the end of file | |
virtual bool | skip_relative (S_I x) override |
skip relatively to the current position | |
virtual bool | truncatable (const infinint &pos) const override |
whether the implementation is able to truncate to the given position | |
virtual infinint | get_position () const override |
get the current read/write position | |
![]() | |
generic_file (gf_mode m) | |
main constructor | |
generic_file (const generic_file &ref) | |
copy constructor | |
generic_file (generic_file &&ref) noexcept | |
move constructor | |
generic_file & | operator= (const generic_file &ref) |
assignment operator | |
generic_file & | operator= (generic_file &&ref) noexcept |
move operator | |
~generic_file () noexcept(false) | |
virtual destructor, | |
void | terminate () |
destructor-like call, except that it is allowed to throw exceptions | |
bool | operator== (generic_file &ref) |
bool | operator!= (generic_file &ref) |
gf_mode | get_mode () const |
retreive the openning mode for this object | |
void | read_ahead (const infinint &amount) |
void | ignore_read_ahead (bool mode) |
virtual U_I | read (char *a, U_I size) override |
read data from the generic_file inherited from proto_generic_file | |
virtual void | write (const char *a, U_I size) override |
write data to the generic_file inherited from proto_generic_file | |
void | write (const std::string &arg) |
write a string to the generic_file | |
S_I | read_back (char &a) |
skip back one char, read on char and skip back one char | |
S_I | read_forward (char &a) |
read one char | |
virtual void | truncate (const infinint &pos) |
truncate file at the given offset | |
virtual void | copy_to (generic_file &ref) |
copy all data from current position to the object in argument | |
virtual void | copy_to (generic_file &ref, const infinint &crc_size, crc *&value) |
copy all data from the current position to the object in argument and computes a CRC value of the transmitted data | |
U_32 | copy_to (generic_file &ref, U_32 size) |
small copy (up to 4GB) with CRC calculation | |
infinint | copy_to (generic_file &ref, infinint size) |
copy the given amount to the object in argument | |
bool | diff (generic_file &f, const infinint &me_read_ahead, const infinint &you_read_ahead, const infinint &crc_size, crc *&value) |
compares the contents with the object in argument | |
bool | diff (generic_file &f, const infinint &me_read_ahead, const infinint &you_read_ahead, const infinint &crc_size, crc *&value, infinint &err_offset) |
void | reset_crc (const infinint &width) |
reset CRC on read or writen data | |
bool | crc_status () const |
to known whether CRC calculation is activated or not | |
crc * | get_crc () |
get CRC of the transfered date since last reset | |
void | sync_write () |
write any pending data | |
void | flush_read () |
be ready to read at current position, reseting all pending data for reading, cached and in compression engine for example | |
![]() | |
proto_generic_file (const proto_generic_file &ref)=default | |
copy constructor | |
proto_generic_file (proto_generic_file &&ref) noexcept=default | |
move constructor | |
proto_generic_file & | operator= (const proto_generic_file &ref)=default |
assignment operator | |
proto_generic_file & | operator= (proto_generic_file &&ref) noexcept=default |
move operator | |
virtual | ~proto_generic_file () noexcept(false) |
virtual destructor | |
Protected Member Functions | |
virtual void | inherited_read_ahead (const infinint &amount) override |
tells the object that several calls to read() will follow to probably obtain at least the given amount of data | |
virtual U_I | inherited_read (char *a, U_I size) override |
implementation of read() operation | |
virtual void | inherited_write (const char *a, U_I size) override |
implementation of the write() operation | |
virtual void | inherited_truncate (const infinint &pos) override |
truncate file at the give offset | |
virtual void | inherited_sync_write () override |
write down any pending data | |
virtual void | inherited_flush_read () override |
reset internal engine, flush caches in order to read the data at current position | |
virtual void | inherited_terminate () override |
destructor-like call, except that it is allowed to throw exceptions | |
![]() | |
void | set_mode (gf_mode x) |
bool | is_terminated () const |
Private Member Functions | |
bool | need_flush_write () const |
void | alloc_buffer (size_t x_size) |
allocate x_size byte in buffer field and set size accordingly | |
void | release_buffer () |
release memory set buffer to nullptr and size to zero | |
void | shift_by_half () |
void | clear_buffer () |
void | flush_write () |
void | fulfill_read () |
U_I | available_in_cache (skippability direction) const |
Private Attributes | |
generic_file * | ref |
underlying file, (not owned by "this', not to be delete by "this") | |
char * | buffer |
data in transit | |
U_I | size |
allocated size | |
U_I | half |
precalculated half = size / 2 | |
U_I | next |
next to read or next place to write to | |
U_I | last |
first byte of invalid data in the cache. we have: next <= last < size | |
U_I | first_to_write |
position of the first byte that need to be written. if greater than last, no byte need writing | |
infinint | buffer_offset |
position of the first byte in buffer | |
bool | shifted_mode |
whether to half flush and shift or totally flush data | |
infinint | eof_offset |
size of the underlying file (read-only mode), set to zero if unknown | |
Additional Inherited Members | |
![]() | |
enum | skippability { skip_backward , skip_forward } |
the cache class implements a fixed length read/write caching mechanism
it is intended to reduce context switches when no compression is used and when reading or writing catalogue through a pipe. The catalogue read and write is done by calling dump/constructor methods of the many objects that a catalogue contains. This makes a lot of small reads or writes, which make very poor performances when used over the network through a pipe to ssh. When compression is used, the problem disapears as the compression engine gather these many small reads or writes into much bigger ones. This in only when there is no compression or encryption that this class is useful (and used). Another target of class cache is to provide limited skippability when data is read of written to pipe (which do not have any skippability)
libdar::cache::cache | ( | generic_file & | hidden, |
bool | shift_mode, | ||
U_I | size = 102400 ) |
hidden | is the file to cache, it is never deleted by the cache object, |
shift_mode | if true, when all cached data has been read, half of the data is flushed from the cache, the other half is shifted and new data take place to fill the cache. This is necessary for sequential reading, but has some CPU overhead. |
size | is the (fixed) size of the cache |
|
inlineoverridevirtual |
get the current read/write position
Implements libdar::generic_file.
Definition at line 73 of file cache.hpp.
References buffer_offset, and next.
Referenced by libdar::cache_global::get_position().
|
inlineoverrideprotectedvirtual |
reset internal engine, flush caches in order to read the data at current position
Implements libdar::generic_file.
|
overrideprotectedvirtual |
implementation of read() operation
[in,out] | a | where to put the data to read |
[in] | size | says how much data to read |
Implements libdar::generic_file.
|
overrideprotectedvirtual |
tells the object that several calls to read() will follow to probably obtain at least the given amount of data
[in] | amount | is the maximum expected amount of data that is known to be read |
Implements libdar::generic_file.
|
inlineoverrideprotectedvirtual |
write down any pending data
Implements libdar::generic_file.
|
inlineoverrideprotectedvirtual |
destructor-like call, except that it is allowed to throw exceptions
Implements libdar::generic_file.
|
overrideprotectedvirtual |
truncate file at the give offset
Implements libdar::generic_file.
|
overrideprotectedvirtual |
implementation of the write() operation
[in] | a | what data to write |
[in] | size | amount of data to write |
Implements libdar::generic_file.
|
inlineprivate |
|
overridevirtual |
skip at the absolute position
[in] | pos | the offset in byte where next read/write operation must start |
Implements libdar::generic_file.
Referenced by libdar::cache_global::skip().
|
overridevirtual |
skip relatively to the current position
Implements libdar::generic_file.
Referenced by libdar::cache_global::skip_relative().
|
overridevirtual |
skip to the end of file
Implements libdar::generic_file.
Referenced by libdar::cache_global::skip_to_eof().
|
overridevirtual |
whether the implementation is able to skip
Implements libdar::generic_file.
Referenced by libdar::cache_global::skippable().
|
overridevirtual |
whether the implementation is able to truncate to the given position
Implements libdar::generic_file.
Referenced by libdar::cache_global::truncatable().
|
private |
position of the first byte in buffer
Definition at line 93 of file cache.hpp.
Referenced by get_position().
|
private |
|
private |
|
private |
|
private |
|
private |
next to read or next place to write to
Definition at line 90 of file cache.hpp.
Referenced by get_position().
|
private |
|
private |